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

data/test/test_paginator.rb

@@ -1,73 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-require "test_helper"
-
-require "highline"
-
-class TestHighLinePaginator < Minitest::Test
-  def setup
-    HighLine.reset
-    @input    = StringIO.new
-    @output   = StringIO.new
-    @terminal = HighLine.new(@input, @output)
-  end
-
-  def test_paging
-    @terminal.page_at = 22
-
-    @input << "\n\n"
-    @input.rewind
-
-    @terminal.say((1..50).map { |n| "This is line #{n}.\n"}.join)
-    assert_equal( (1..22).map { |n| "This is line #{n}.\n"}.join +
-                  "\n-- press enter/return to continue or q to stop -- \n\n" +
-                  (23..44).map { |n| "This is line #{n}.\n"}.join +
-                  "\n-- press enter/return to continue or q to stop -- \n\n" +
-                  (45..50).map { |n| "This is line #{n}.\n"}.join,
-                  @output.string )
-  end
-
-  def test_statement_lines_count_equal_to_page_at_shouldnt_paginate
-    @terminal.page_at = 6
-
-    @input << "\n"
-    @input.rewind
-
-    list = "a\nb\nc\nd\ne\nf\n"
-
-    @terminal.say(list)
-    assert_equal(list, @output.string)
-  end
-
-  def test_statement_with_one_line_bigger_than_page_at_should_paginate
-    @terminal.page_at = 6
-
-    @input << "\n"
-    @input.rewind
-
-    list = "a\nb\nc\nd\ne\nf\ng\n"
-
-    paginated =
-      "a\nb\nc\nd\ne\nf\n" \
-      "\n-- press enter/return to continue or q to stop -- \n\n" \
-      "g\n"
-
-    @terminal.say(list)
-    assert_equal(paginated, @output.string)
-  end
-
-  def test_quiting_paging_shouldnt_raise
-    # See https://github.com/JEG2/highline/issues/168
-
-    @terminal.page_at = 6
-
-    @input << "q"
-    @input.rewind
-
-    list = "a\nb\nc\nd\ne\nf\n"
-
-    # expect not to raise an error on next line
-    @terminal.say(list)
-  end
-end

data/test/test_question_asker.rb

@@ -1,20 +0,0 @@
-require "test_helper"
-
-class TestQuestion < Minitest::Test
-  def setup
-    @input    = StringIO.new
-    @output   = StringIO.new
-    @highline = HighLine.new(@input, @output)
-
-    @question = HighLine::Question.new("How are you?", nil)
-    @asker    = HighLine::QuestionAsker.new(@question, @highline)
-  end
-
-  def test_ask_once
-    answer = "Very good, thanks for asking!"
-
-    @input.string = answer
-
-    assert_equal answer, @asker.ask_once
-  end
-end

data/test/test_simulator.rb

@@ -1,24 +0,0 @@
-require "test_helper"
-
-require "highline/import"
-require "highline/simulate"
-
-class SimulatorTest < Minitest::Test
-  def setup
-    input     = StringIO.new
-    output    = StringIO.new
-    $terminal = HighLine.new(input, output)
-  end
-
-  def test_simulator
-    HighLine::Simulate.with("Bugs Bunny", "18") do
-      name = ask("What is your name?")
-
-      assert_equal "Bugs Bunny", name
-
-      age = ask("What is your age?")
-
-      assert_equal "18", age
-    end
-  end
-end

data/test/test_string_extension.rb

@@ -1,72 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# tc_string_extension.rb
-#
-#  Created by Richard LeBer 2011-06-27
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-
-require "test_helper"
-
-require "highline"
-require "stringio"
-require "string_methods"
-
-
-# FakeString is here just to avoid
-# using HighLine.colorize_strings
-# on tests
-
-class FakeString < String
-  include HighLine::StringExtensions
-end
-
-class TestStringExtension < Minitest::Test
-  def setup
-    HighLine.reset
-    @string = FakeString.new "string"
-  end
-
-  def teardown
-    HighLine.reset
-  end
-
-  include StringMethods
-
-  def test_Highline_String_is_yaml_serializable
-    require 'yaml'
-    unless Gem::Version.new(YAML::VERSION) < Gem::Version.new("2.0.2")
-      highline_string = HighLine::String.new("Yaml didn't messed with HighLine::String")
-      yaml_highline_string = highline_string.to_yaml
-      yaml_loaded_string = YAML.load(yaml_highline_string)
-
-      assert_equal "Yaml didn't messed with HighLine::String", yaml_loaded_string
-      assert_equal highline_string, yaml_loaded_string
-      assert_instance_of HighLine::String, yaml_loaded_string
-    end
-  end
-
-  def test_highline_string_respond_to_color
-    assert HighLine::String.new("highline string").respond_to? :color
-  end
-
-  def test_normal_string_doesnt_respond_to_color
-    refute "normal_string".respond_to? :color
-  end
-
-  def test_highline_string_still_raises_for_non_available_messages
-    assert_raises(NoMethodError) do
-      @string.unknown_message
-    end
-  end
-
-  def test_String_includes_StringExtension_when_receives_colorize_strings
-    @include_received = 0
-    caller = Proc.new { @include_received += 1 }
-    ::String.stub :include, caller do
-      HighLine.colorize_strings
-    end
-    assert_equal 1, @include_received
-  end
-end

data/test/test_string_highline.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# tc_highline_string.rb
-#
-#  Created by Richard LeBer 2011-06-27
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-
-require "test_helper"
-
-require "highline"
-require "stringio"
-require "string_methods"
-
-class TestHighLineString < Minitest::Test
-  def setup
-    HighLine.reset
-    @string = HighLine::String.new("string")
-  end
-
-  def test_string_class
-    # Basic constructor
-    assert_equal HighLine::String, @string.class
-    assert_equal "string", @string
-    
-    # Alternative constructor method
-    new_string = HighLine::String("string")
-    assert_equal HighLine::String, new_string.class
-    assert_equal @string, new_string
-    
-    # String methods work
-    assert_equal 6, @string.size
-    assert_equal "STRING", @string.upcase
-  end
-
-  include StringMethods
-  
-  def test_string_class_is_unchanged
-    assert_raises(::NoMethodError) { "string".color(:blue) }
-  end
-end

data/test/test_style.rb

@@ -1,613 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-# tc_style.rb
-#
-#  Created by Richard LeBer on 2011-06-11.
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-
-require "test_helper"
-
-require "highline"
-require "stringio"
-
-class TestStyle < Minitest::Test
-  
-  def setup
-    HighLine.reset
-    @input    = StringIO.new
-    @output   = StringIO.new
-    @terminal = HighLine.new(@input, @output)  
-    @style1   = HighLine::Style.new(:name=>:foo, :code=>"\e[99m", :rgb=>[1,2,3])
-    @style2   = HighLine::Style.new(:name=>:lando, :code=>"\e[98m")
-    @style3   = HighLine::Style.new(:name=>[:foo, :lando], :list=>[:foo, :lando])
-    @style4   = HighLine::Style(:rgb_654321)
-    @added_styles_on_setup = 4 # update here if added more styles
-    @added_codes_to_index  = 3 # :foo, :lando and :rgb_654321
-  end
-
-  def test_clear_index_reset_styles_to_builtin
-    styles_size_after_setup = HighLine::Style.list.size
-    expected_styles_size = styles_size_after_setup - @added_styles_on_setup
-
-    HighLine::Style.clear_index
-    styles_size_after_clear_index = HighLine::Style.list.size
-
-    assert_equal expected_styles_size, styles_size_after_clear_index
-  end
-
-  def test_clear_index_reset_code_index_to_builtin
-    code_index = HighLine::Style.code_index
-    code_index_array = code_index.map { |code, style_array| style_array }.flatten
-    expected_code_index_array_size = code_index_array.size - @added_codes_to_index
-
-    HighLine::Style.clear_index
-
-    cleared_code_index = HighLine::Style.code_index
-    cleared_code_index_array = cleared_code_index.map { |code, style_array| style_array }.flatten
-
-    assert_equal  expected_code_index_array_size, cleared_code_index_array.size
-  end
-
-  def test_style_method
-    # Retrieve a style from an existing Style (no new Style created)
-    new_style = @style1.dup # This will replace @style1 in the indexes
-    s = HighLine.Style(@style1)
-    assert_instance_of HighLine::Style, s
-    assert_same new_style, s # i.e. s===the latest style created, but not the one searched for
-
-    # Retrieve a style from a new Style (no new Style created)
-    s2 = HighLine::Style.new(:name=>:bar, :code=>"\e[97m")
-    s = HighLine.Style(s2)
-    assert_instance_of HighLine::Style, s
-    assert_same s2, s
-
-    # Create a builtin style from an existing ANSI escape string
-    s = HighLine.Style("\e[1m")
-    assert_instance_of HighLine::Style, s
-    assert_nil s.list
-    assert_equal "\e[1m", s.code
-    assert_equal :bold, s.name
-    assert s.builtin
-
-    # Create a builtin style from a new ANSI escape string
-    s = HighLine.Style("\e[96m")
-    assert_instance_of HighLine::Style, s
-    assert_nil s.list
-    assert_equal "\e[96m", s.code
-    assert s.builtin
-
-    # Create a non-builtin style from a string
-    s = HighLine.Style("\e[109m")
-    assert_instance_of HighLine::Style, s
-    assert_nil s.list
-    assert_equal "\e[109m", s.code
-    refute s.builtin
-
-    # Create a builtin style from a symbol
-    s = HighLine.Style(:red)
-    assert_instance_of HighLine::Style, s
-    assert_nil s.list
-    assert_equal :red, s.name
-    assert s.builtin
-
-    # Retrieve an existing style by name (no new Style created)
-    s = HighLine.Style(@style2.name)
-    assert_instance_of HighLine::Style, s
-    assert_same @style2, s
-    
-    # See below for color scheme tests
-    
-    # Create style from a Hash
-    s = HighLine.Style(:name=>:han, :code=>"blah", :rgb=>'phooey')
-    assert_instance_of HighLine::Style, s
-    assert_equal :han, s.name
-    assert_equal "blah", s.code
-    assert_equal "phooey", s.rgb
-    
-    # Create style from an RGB foreground color code
-    s = HighLine.Style(:rgb_1f2e3d)
-    assert_instance_of HighLine::Style, s
-    assert_equal :rgb_1f2e3d, s.name
-    assert_equal "\e[38;5;23m", s.code # Trust me; more testing below
-    assert_equal [31,46,61], s.rgb     # 0x1f==31, 0x2e==46, 0x3d=61
-    
-    # Create style from an RGB background color code
-    s = HighLine.Style(:on_rgb_1f2e3d)
-    assert_instance_of HighLine::Style, s
-    assert_equal :on_rgb_1f2e3d, s.name
-    assert_equal "\e[48;5;23m", s.code # Trust me; more testing below
-    assert_equal [31,46,61], s.rgb     # 0x1f==31, 0x2e==46, 0x3d=61
-
-    # Create a style list
-    s1 = HighLine.Style(:bold, :red)
-    assert_instance_of HighLine::Style, s1
-    assert_equal [:bold, :red], s1.list
-    
-    # Find an existing style list
-    s2 = HighLine.Style(:bold, :red)
-    assert_instance_of HighLine::Style, s2
-    assert_same s1, s2
-
-    # Create a style list with nils
-    s1 = HighLine.Style(:underline, nil, :blue)
-    assert_instance_of HighLine::Style, s1
-    assert_equal [:underline, :blue], s1.list
-    
-    # Raise an error for an undefined style
-    assert_raises(::NameError) { HighLine.Style(:fubar) }
-  end
-  
-  def test_no_color_scheme
-    HighLine.color_scheme = nil
-    assert_raises(::NameError) { HighLine.Style(:critical) }
-  end
-  
-  def test_with_color_scheme
-    HighLine.color_scheme = HighLine::SampleColorScheme.new
-    s = HighLine.Style(:critical)
-    assert_instance_of HighLine::Style, s
-    assert_equal :critical, s.name
-    assert_equal [:yellow, :on_red], s.list
-  end
-  
-  def test_builtin_foreground_colors_defined
-    HighLine::COLORS.each do |color|
-      style = HighLine.const_get(color+'_STYLE')
-      assert_instance_of HighLine::Style, style
-      assert_equal color.downcase.to_sym, style.name
-      assert style.builtin
-      code = HighLine.const_get(color)
-      assert_instance_of String, code, "Bad code for #{color}"
-    end
-  end
-  
-  def test_builtin_background_colors_defined
-    HighLine::COLORS.each do |color|
-      style = HighLine.const_get('ON_' + color+'_STYLE')
-      assert_instance_of HighLine::Style, style
-      assert_equal "ON_#{color}".downcase.to_sym, style.name
-      assert style.builtin
-      code = HighLine.const_get('ON_' + color)
-      assert_instance_of String, code, "Bad code for ON_#{color}"
-    end
-  end
-  
-  def test_builtin_styles_defined
-    HighLine::STYLES.each do |style_constant|
-      style = HighLine.const_get(style_constant+'_STYLE')
-      assert_instance_of HighLine::Style, style
-      assert_equal style_constant.downcase.to_sym, style.name
-      assert style.builtin
-      code = HighLine.const_get(style_constant)
-      assert_instance_of String, code, "Bad code for #{style_constant}"
-    end
-  end
-  
-  def test_index
-    # Add a Style with a new name and code
-    assert_nil HighLine::Style.list[:s1]
-    assert_nil HighLine::Style.code_index['foo']
-    s1 = HighLine::Style.new(:name=>:s1, :code=>'foo')
-    refute_nil HighLine::Style.list[:s1]
-    assert_same s1, HighLine::Style.list[:s1]
-    assert_equal :s1, HighLine::Style.list[:s1].name
-    assert_equal 'foo', HighLine::Style.list[:s1].code
-    styles = HighLine::Style.list.size
-    codes  = HighLine::Style.code_index.size
-    assert_instance_of Array, HighLine::Style.code_index['foo']
-    assert_equal 1, HighLine::Style.code_index['foo'].size
-    assert_same s1, HighLine::Style.code_index['foo'].last
-    assert_equal :s1, HighLine::Style.code_index['foo'].last.name
-    assert_equal 'foo', HighLine::Style.code_index['foo'].last.code
-
-    # Add another Style with a new name and code
-    assert_nil HighLine::Style.list[:s2]
-    assert_nil HighLine::Style.code_index['bar']
-    s2 = HighLine::Style.new(:name=>:s2, :code=>'bar')
-    assert_equal styles+1, HighLine::Style.list.size
-    assert_equal codes+1,  HighLine::Style.code_index.size
-    refute_nil HighLine::Style.list[:s2]
-    assert_same s2, HighLine::Style.list[:s2]
-    assert_equal :s2, HighLine::Style.list[:s2].name
-    assert_equal 'bar', HighLine::Style.list[:s2].code
-    assert_instance_of Array, HighLine::Style.code_index['bar']
-    assert_equal 1, HighLine::Style.code_index['bar'].size
-    assert_same s2, HighLine::Style.code_index['bar'].last
-    assert_equal :s2, HighLine::Style.code_index['bar'].last.name
-    assert_equal 'bar', HighLine::Style.code_index['bar'].last.code
-    
-    # Add a Style with an existing name
-    s3_before = HighLine::Style.list[:s2]
-    refute_nil HighLine::Style.list[:s2]
-    assert_nil HighLine::Style.code_index['baz']
-    s3 = HighLine::Style.new(:name=>:s2, :code=>'baz')
-    refute_same s2, s3
-    refute_same s3_before, s3
-    assert_equal styles+1, HighLine::Style.list.size
-    assert_equal codes+2,  HighLine::Style.code_index.size
-    refute_nil HighLine::Style.list[:s2]
-    assert_same s3, HighLine::Style.list[:s2]
-    refute_same s2, HighLine::Style.list[:s2]
-    assert_equal :s2, HighLine::Style.list[:s2].name
-    assert_equal 'baz', HighLine::Style.list[:s2].code
-    assert_instance_of Array, HighLine::Style.code_index['baz']
-    assert_equal 1, HighLine::Style.code_index['baz'].size
-    assert_same s3, HighLine::Style.code_index['baz'].last
-    assert_equal :s2, HighLine::Style.code_index['baz'].last.name
-    assert_equal 'baz', HighLine::Style.code_index['baz'].last.code
-
-    # Add a Style with an existing code
-    assert_equal 1, HighLine::Style.code_index['baz'].size
-    s4 = HighLine::Style.new(:name=>:s4, :code=>'baz')
-    assert_equal styles+2, HighLine::Style.list.size
-    assert_equal codes+2,  HighLine::Style.code_index.size
-    refute_nil HighLine::Style.list[:s4]
-    assert_same s4, HighLine::Style.list[:s4]
-    assert_equal :s4, HighLine::Style.list[:s4].name
-    assert_equal 'baz', HighLine::Style.list[:s4].code
-    assert_equal 2, HighLine::Style.code_index['baz'].size
-    assert_same s3, HighLine::Style.code_index['baz'].first # Unchanged from last time
-    assert_equal :s2, HighLine::Style.code_index['baz'].first.name # Unchanged from last time
-    assert_equal 'baz', HighLine::Style.code_index['baz'].first.code # Unchanged from last time
-    assert_same s4, HighLine::Style.code_index['baz'].last
-    assert_equal :s4, HighLine::Style.code_index['baz'].last.name
-    assert_equal 'baz', HighLine::Style.code_index['baz'].last.code
-  end
-  
-  def test_rgb_hex
-    assert_equal "abcdef", HighLine::Style.rgb_hex("abcdef")
-    assert_equal "ABCDEF", HighLine::Style.rgb_hex("AB","CD","EF")
-    assert_equal "010203", HighLine::Style.rgb_hex(1,2,3)
-    assert_equal "123456", HighLine::Style.rgb_hex(18,52,86)
-  end
-  
-  def test_rgb_parts
-    assert_equal [1,2,3], HighLine::Style.rgb_parts("010203")
-    assert_equal [18,52,86], HighLine::Style.rgb_parts("123456")
-  end
-  
-  def test_rgb
-    s = HighLine::Style.rgb(1, 2, 3)
-    assert_instance_of HighLine::Style, s
-    assert_equal :rgb_010203, s.name
-    assert_equal [1,2,3], s.rgb
-    assert_equal "\e[38;5;16m", s.code
-
-    s = HighLine::Style.rgb("12", "34","56")
-    assert_instance_of HighLine::Style, s
-    assert_equal :rgb_123456, s.name
-    assert_equal [0x12, 0x34, 0x56], s.rgb
-    assert_equal "\e[38;5;24m", s.code
-
-    s = HighLine::Style.rgb("abcdef")
-    assert_instance_of HighLine::Style, s
-    assert_equal :rgb_abcdef, s.name
-    assert_equal [0xab, 0xcd, 0xef], s.rgb
-    assert_equal "\e[38;5;189m", s.code
-  end
-  
-  def test_rgb_number
-    # ANSI RGB coding splits 0..255 into equal sixths, and then the 
-    # red green and blue are encoded in base 6, plus 16, i.e.
-    # 16 + 36*(red_level) + 6*(green_level) + blue_level,
-    # where each of red_level, green_level, and blue_level are in
-    # the range 0..5
-    
-    # This test logic works because 42 is just below 1/6 of 255,
-    # and 43 is just above
-    
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number(  0,  0,  0)
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number(  0,  0, 42)
-    assert_equal 16 + 0*36 + 0*6 + 1, HighLine::Style.rgb_number(  0,  0, 43)
-
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number(  0, 42,  0)
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number(  0, 42, 42)
-    assert_equal 16 + 0*36 + 0*6 + 1, HighLine::Style.rgb_number(  0, 42, 43)
-
-    assert_equal 16 + 0*36 + 1*6 + 0, HighLine::Style.rgb_number(  0, 43,  0)
-    assert_equal 16 + 0*36 + 1*6 + 0, HighLine::Style.rgb_number(  0, 43, 42)
-    assert_equal 16 + 0*36 + 1*6 + 1, HighLine::Style.rgb_number(  0, 43, 43)
-
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number( 42,  0,  0)
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number( 42,  0, 42)
-    assert_equal 16 + 0*36 + 0*6 + 1, HighLine::Style.rgb_number( 42,  0, 43)
-
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number( 42, 42,  0)
-    assert_equal 16 + 0*36 + 0*6 + 0, HighLine::Style.rgb_number( 42, 42, 42)
-    assert_equal 16 + 0*36 + 0*6 + 1, HighLine::Style.rgb_number( 42, 42, 43)
-
-    assert_equal 16 + 0*36 + 1*6 + 0, HighLine::Style.rgb_number( 42, 43,  0)
-    assert_equal 16 + 0*36 + 1*6 + 0, HighLine::Style.rgb_number( 42, 43, 42)
-    assert_equal 16 + 0*36 + 1*6 + 1, HighLine::Style.rgb_number( 42, 43, 43)
-
-    assert_equal 16 + 1*36 + 0*6 + 0, HighLine::Style.rgb_number( 43,  0,  0)
-    assert_equal 16 + 1*36 + 0*6 + 0, HighLine::Style.rgb_number( 43,  0, 42)
-    assert_equal 16 + 1*36 + 0*6 + 1, HighLine::Style.rgb_number( 43,  0, 43)
-
-    assert_equal 16 + 1*36 + 0*6 + 0, HighLine::Style.rgb_number( 43, 42,  0)
-    assert_equal 16 + 1*36 + 0*6 + 0, HighLine::Style.rgb_number( 43, 42, 42)
-    assert_equal 16 + 1*36 + 0*6 + 1, HighLine::Style.rgb_number( 43, 42, 43)
-
-    assert_equal 16 + 1*36 + 1*6 + 0, HighLine::Style.rgb_number( 43, 43,  0)
-    assert_equal 16 + 1*36 + 1*6 + 0, HighLine::Style.rgb_number( 43, 43, 42)
-    assert_equal 16 + 1*36 + 1*6 + 1, HighLine::Style.rgb_number( 43, 43, 43)
-    
-    assert_equal 16 + 5*36 + 5*6 + 5, HighLine::Style.rgb_number(255,255,255)
-  end
-  
-  def test_ansi_rgb_to_hex
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "00002b", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 1)
-
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "00002b", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 1)
-
-    assert_equal "002b00", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 1*6 + 0)
-    assert_equal "002b00", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 1*6 + 0)
-    assert_equal "002b2b", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 1*6 + 1)
-
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "00002b", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 1)
-
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "000000", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 0)
-    assert_equal "00002b", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 0*6 + 1)
-
-    assert_equal "002b00", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 1*6 + 0)
-    assert_equal "002b00", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 1*6 + 0)
-    assert_equal "002b2b", HighLine::Style.ansi_rgb_to_hex(16 + 0*36 + 1*6 + 1)
-
-    assert_equal "2b0000", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 0*6 + 0)
-    assert_equal "2b0000", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 0*6 + 0)
-    assert_equal "2b002b", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 0*6 + 1)
-
-    assert_equal "2b0000", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 0*6 + 0)
-    assert_equal "2b0000", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 0*6 + 0)
-    assert_equal "2b002b", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 0*6 + 1)
-
-    assert_equal "2b2b00", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 1*6 + 0)
-    assert_equal "2b2b00", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 1*6 + 0)
-    assert_equal "2b2b2b", HighLine::Style.ansi_rgb_to_hex(16 + 1*36 + 1*6 + 1)
-    
-    # 0xd5 is the smallest number where n/255.0*6.0 > 5
-    assert_equal "d5d5d5", HighLine::Style.ansi_rgb_to_hex(16 + 5*36 + 5*6 + 5)
-  end
-  
-  def test_list
-    list_size = HighLine::Style.list.size
-    # Add a Style with a new name and code
-    assert_nil HighLine::Style.list[:s5]
-    s5 = HighLine::Style.new(:name=>:s5, :code=>'foo')
-    refute_nil HighLine::Style.list[:s5]
-    assert_equal list_size+1, HighLine::Style.list.size
-    refute_nil HighLine::Style.list[:s5]
-    assert_same s5, HighLine::Style.list[:s5]
-    assert_equal :s5, HighLine::Style.list[:s5].name
-    assert_equal 'foo', HighLine::Style.list[:s5].code
-
-    # Add another Style with a new name and code
-    assert_nil HighLine::Style.list[:s6]
-    s6 = HighLine::Style.new(:name=>:s6, :code=>'bar')
-    assert_equal list_size+2, HighLine::Style.list.size
-    refute_nil HighLine::Style.list[:s6]
-    assert_same s6, HighLine::Style.list[:s6]
-    assert_equal :s6, HighLine::Style.list[:s6].name
-    assert_equal 'bar', HighLine::Style.list[:s6].code
-    
-    # Add a Style with an existing name
-    s7 = HighLine::Style.new(:name=>:s6, :code=>'baz')
-    assert_equal list_size+2, HighLine::Style.list.size # No net addition to list
-    refute_nil HighLine::Style.list[:s6]
-    assert_same s7, HighLine::Style.list[:s6] # New one replaces old one
-    refute_same s6, HighLine::Style.list[:s6]
-    assert_equal :s6, HighLine::Style.list[:s6].name
-    assert_equal 'baz', HighLine::Style.list[:s6].code
-  end
-  
-  def test_code_index
-    list_size = HighLine::Style.code_index.size
-    
-    # Add a Style with a new name and code
-    assert_nil HighLine::Style.code_index['chewie']
-    HighLine::Style.new(:name=>:s8, :code=>'chewie')
-    assert_equal list_size+1, HighLine::Style.code_index.size
-    assert_instance_of Array, HighLine::Style.code_index['chewie']
-    assert_equal 1, HighLine::Style.code_index['chewie'].size
-    assert_equal :s8, HighLine::Style.code_index['chewie'].last.name
-    assert_equal 'chewie', HighLine::Style.code_index['chewie'].last.code
-
-    # Add another Style with a new name and code
-    assert_nil HighLine::Style.code_index['c3po']
-    HighLine::Style.new(:name=>:s9, :code=>'c3po')
-    assert_equal list_size+2,  HighLine::Style.code_index.size
-    assert_instance_of Array, HighLine::Style.code_index['c3po']
-    assert_equal 1, HighLine::Style.code_index['c3po'].size
-    assert_equal :s9, HighLine::Style.code_index['c3po'].last.name
-    assert_equal 'c3po', HighLine::Style.code_index['c3po'].last.code
-
-    # Add a Style with an existing code
-    assert_equal 1, HighLine::Style.code_index['c3po'].size
-    HighLine::Style.new(:name=>:s10, :code=>'c3po')
-    assert_equal list_size+2,  HighLine::Style.code_index.size
-    assert_equal 2, HighLine::Style.code_index['c3po'].size
-    assert_equal :s10, HighLine::Style.code_index['c3po'].last.name
-    assert_equal 'c3po', HighLine::Style.code_index['c3po'].last.code
-  end
-  
-  def test_uncolor
-    # Normal color
-    assert_equal "This should be reverse underlined magenta!\n",
-        HighLine::Style.uncolor("This should be \e[7m\e[4m\e[35mreverse underlined magenta\e[0m!\n" )
-
-    # RGB color
-    assert_equal "This should be rgb_906030!\n",
-        HighLine::Style.uncolor("This should be \e[38;5;137mrgb_906030\e[0m!\n" )
-  end
-  
-  def test_color
-    assert_equal "\e[99mstring\e[0m", @style1.color("string") # simple style
-    assert_equal "\e[99m\e[98mstring\e[0m", @style3.color("string") # Style list
-  end
-  
-  def test_code
-    assert_equal "\e[99m", @style1.code # simple style
-    assert_equal "\e[99m\e[98m", @style3.code # Style list
-  end
-  
-  def test_red
-    assert_equal 0x65, @style4.red
-    assert_equal 0, HighLine::Style(:none).red # Probably reliable
-    assert_equal 0, HighLine::Style(:black).red # Probably reliable
-    assert_equal 255, HighLine::Style(:bright_magenta).red # Seems to be reliable
-    assert_equal 255, HighLine::Style(:on_none).red # Probably reliable
-  end
-  
-  def test_green
-    assert_equal 0x43, @style4.green
-    assert_equal 0, HighLine::Style(:none).green # Probably reliable
-    assert_equal 0, HighLine::Style(:black).green # Probably reliable
-    assert       240 <= HighLine::Style(:bright_cyan).green # Probably reliable
-    assert_equal 255, HighLine::Style(:on_none).green # Probably reliable
-  end
-  
-  def test_blue
-    assert_equal 0x21, @style4.blue
-    assert_equal 0, HighLine::Style(:none).blue # Probably reliable
-    assert_equal 0, HighLine::Style(:black).blue # Probably reliable
-    assert_equal 255, HighLine::Style(:bright_blue).blue # Probably reliable
-    assert_equal 255, HighLine::Style(:on_none).blue # Probably reliable
-  end
-  
-  def test_builtin
-    assert HighLine::Style(:red).builtin
-    assert !@style1.builtin
-  end
-  
-  def test_variant
-    style1_name = @style1.name
-    style1_code = @style1.code
-    style1_rgb = @style1.rgb
-    
-    s1 = @style1.variant(:new_foo1, :code=>'abracadabra')
-    assert_instance_of HighLine::Style, s1
-    refute_same @style1, s1 # This is a copy
-    assert_equal :new_foo1, s1.name # Changed
-    assert_equal 'abracadabra', s1.code # Changed
-    assert_equal [1,2,3], s1.rgb # Unchanged
-    
-    s2 = @style1.variant(:new_foo2, :increment=>-15)
-    assert_instance_of HighLine::Style, s2
-    refute_same @style1, s2     # This is a copy
-    assert_equal :new_foo2, s2.name # Changed
-    assert_equal "\e[84m", s2.code  # 99 (original code) - 15
-    assert_equal [1,2,3], s2.rgb    # Unchanged
-    
-    s3 = @style1.variant(:new_foo3, :code=>"\e[55m", :increment=>15)
-    assert_instance_of HighLine::Style, s3
-    refute_same @style1, s3     # This is a copy
-    assert_equal :new_foo3, s3.name # Changed
-    assert_equal "\e[70m", s3.code  # 99 (new code) + 15
-    assert_equal [1,2,3], s3.rgb    # Unchanged
-    
-    s4 = @style1.variant(:new_foo4, :code=>"\e[55m", :increment=>15, :rgb=>"blah")
-    assert_instance_of HighLine::Style, s4
-    refute_same @style1, s4     # This is a copy
-    assert_equal :new_foo4, s4.name # Changed
-    assert_equal "\e[70m", s4.code  # 99 (new code) + 15
-    assert_equal 'blah', s4.rgb     # Changed
-
-    s5 = @style1.variant(:new_foo5)
-    assert_instance_of HighLine::Style, s5
-    refute_same @style1, s5     # This is a copy
-    assert_equal :new_foo5, s5.name # Changed
-    assert_equal "\e[99m", s5.code  # Unchanged
-    assert_equal [1,2,3], s5.rgb    # Unchanged
-
-    # No @style1's have been harmed in the running of this test
-    assert_equal style1_name, @style1.name
-    assert_equal style1_code, @style1.code
-    assert_equal style1_rgb,  @style1.rgb
-    
-    assert_raises(::RuntimeError) { @style3.variant(:new_foo6) } # Can't create a variant of a list style
-  end
-  
-  def test_on
-    style1_name = @style1.name
-    style1_code = @style1.code
-    style1_rgb = @style1.rgb
-    
-    s1 = @style1.on
-    assert_instance_of HighLine::Style, s1
-    refute_same @style1, s1     # This is a copy
-    assert_equal :on_foo, s1.name   # Changed
-    assert_equal "\e[109m", s1.code # Changed
-    assert_equal [1,2,3], s1.rgb    # Unchanged
-
-    # No @style1's have been harmed in the running of this test
-    assert_equal style1_name, @style1.name
-    assert_equal style1_code, @style1.code
-    assert_equal style1_rgb,  @style1.rgb
-    
-    assert_raises(::RuntimeError) { @style3.on } # Can't create a variant of a list style
-  end
-  
-  def test_bright
-    style1_name = @style1.name
-    style1_code = @style1.code
-    style1_rgb = @style1.rgb
-    
-    s1 = @style1.bright
-    assert_instance_of HighLine::Style, s1
-    refute_same @style1, s1         # This is a copy
-    assert_equal :bright_foo, s1.name   # Changed
-    assert_equal "\e[159m", s1.code     # Changed
-    assert_equal [129,130,131], s1.rgb  # Changed
-
-    # No @style1's have been harmed in the running of this test
-    assert_equal style1_name, @style1.name
-    assert_equal style1_code, @style1.code
-    assert_equal style1_rgb,  @style1.rgb
-    
-    s2_base = HighLine::Style.new(:name=>:leia, :code=>"\e[92m", :rgb=>[0,0,14])
-    s2 = s2_base.bright
-    assert_instance_of HighLine::Style, s2
-    refute_same s2_base, s2         # This is a copy
-    assert_equal :bright_leia, s2.name  # Changed
-    assert_equal "\e[152m", s2.code     # Changed
-    assert_equal [0,0,142], s2.rgb      # Changed
-    
-    s3_base = HighLine::Style.new(:name=>:luke, :code=>"\e[93m", :rgb=>[20,21,0])
-    s3 = s3_base.bright
-    assert_instance_of HighLine::Style, s3
-    refute_same s3_base, s3         # This is a copy
-    assert_equal :bright_luke, s3.name  # Changed
-    assert_equal "\e[153m", s3.code     # Changed
-    assert_equal [148,149,0], s3.rgb    # Changed
-    
-    s4_base = HighLine::Style.new(:name=>:r2d2, :code=>"\e[94m", :rgb=>[0,0,0])
-    s4 = s4_base.bright
-    assert_instance_of HighLine::Style, s4
-    refute_same s4_base, s4         # This is a copy
-    assert_equal :bright_r2d2, s4.name  # Changed
-    assert_equal "\e[154m", s4.code     # Changed
-    assert_equal [128,128,128], s4.rgb  # Changed; special case
-    
-    assert_raises(::RuntimeError) { @style3.bright } # Can't create a variant of a list style
-  end
-
-  def test_light_do_the_same_as_bright
-    bright_style = @style1.bright
-    light_style  = @style1.light
-
-    refute_equal bright_style, light_style
-    assert_equal :bright_foo, bright_style.name
-    assert_equal :light_foo, light_style.name
-    assert_equal bright_style.code, light_style.code
-    assert_equal bright_style.rgb, light_style.rgb
-  end
-end