riel 1.0.0

data/test/riel/optproc_test.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+require 'tempfile'
+require 'rubyunit'
+require 'riel/optproc'
+
+class OptProcTestCase < RUNIT::TestCase
+
+  def setup
+    # ignore what they have in ENV[HOME]    
+    ENV['HOME'] = '/this/should/not/exist'
+  end
+
+  def do_test(args, exp, &blk)
+    expected = DEFAULTS.merge(exp)
+
+    # ignore what they have in ENV[HOME]    
+    ENV['HOME'] = '/this/should/not/exist'
+
+    origargs = args.dup
+    
+    gopt = GlarkOptions.instance
+    gopt.run(args)
+    
+    expected.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |opt, exval|
+      meth = gopt.method(opt)
+      val  = meth.call
+      if val.kind_of? Array
+        assert_equal exval.length, val.length, "#{opt} => #{exval.class}.length #{exval.inspect}; #{val.class}.length #{val.inspect}; #{origargs.inspect}"
+        (0 ... exval.length).each do |idx|
+          assert_equal exval[idx], val[idx], "#{opt}[#{idx}] => #{exval.class}.length #{exval.inspect}; #{val.class}.length #{val.inspect}; #{origargs.inspect}"
+        end
+      else
+        assert_equal exval, val, "#{opt} => #{exval.class} #{exval.inspect}; #{val.class} #{val.inspect}; #{origargs.inspect}"
+      end
+    end
+    
+    blk.call(gopt) if blk
+
+    gopt.reset
+  end
+
+  def do_match_tag_test(opt, exp, tag)
+    m = opt.match([ tag ])
+    match = nil
+    if exp.respond_to? :include?
+      match = exp.include? m
+    else
+      match = exp == m
+    end
+    assert match, "match_tag(#{tag}): expected: #{exp.inspect}; actual: #{m.inspect}"
+  end
+  
+  def test_match_tag
+    @after = "nothing"
+    opt = OptProc::Option.new(:tags => %w{ --after-context -A }, :arg => [ :integer ])
+    
+    %w{ --after-context --after-context=3 -A }.each do |tag|
+      do_match_tag_test(opt, 1.0, tag)
+    end
+
+    do_match_tag_test(opt, nil, '-b')
+    
+    # we don't support case insensitivity (which is insensitive of us):
+    %w{ --After-Context --AFTER-CONTEXT=3 -a }.each do |tag|
+      do_match_tag_test(opt, nil, tag)
+    end
+
+    %w{ --after --after=3 }.each do |tag|
+      do_match_tag_test(opt, 0.07, tag)
+    end
+
+    %w{ --after-cont --after-cont=3 }.each do |tag|
+      do_match_tag_test(opt, 0.12, tag)
+    end
+
+    %w{ --aft --aft=3 }.each do |tag|
+      do_match_tag_test(opt, 0.05, tag)
+    end
+  end
+
+  def do_match_value_test(opt, exp, val)
+    m = opt.match_value(val)
+    assert !!m == !!exp, "match value #{val}; expected: #{exp.inspect}; actual: #{m.inspect}"
+  end
+
+  def test_value_none
+    opt = OptProc::Option.new(:arg  => [ :none ])
+
+    {
+      '34'    => nil,
+      '43'    => nil,
+      '34.12' => nil
+    }.each do |val, exp|
+      do_match_value_test(opt, exp, val)
+    end
+  end
+
+  def test_value_integer
+    opt = OptProc::Option.new(:arg => [ :integer ])
+
+    {
+      '34'    => true,
+      '43'    => true,
+      '34.12' => nil,
+      '-34'   => true,
+      '+34'   => true,
+    }.each do |val, exp|
+      do_match_value_test(opt, exp, val)
+    end
+  end
+
+  def test_value_float
+    opt = OptProc::Option.new(:arg  => [ :float ])
+
+    {
+      '34'    => true,
+      '43'    => true,
+      '34.12' => true,
+      '.12'   => true,
+      '.'     => false,
+      '12.'   => false,
+    }.each do |val, exp|
+      do_match_value_test(opt, exp, val)
+    end
+  end
+
+  def test_value_string
+    opt = OptProc::Option.new(:arg  => [ :string ])
+
+    {
+      '34'    => true,
+      '43'    => true,
+      '34.12' => true,
+      '.12'   => true,
+      '.'     => true,
+      '12.'   => true,
+      'hello' => true,
+      'a b c' => true,
+      ''      => true,
+    }.each do |val, exp|
+      [ 
+        '"' + val + '"',
+        "'" + val + "'",
+        val,
+      ].each do |qval|
+        do_match_value_test(opt, exp, qval)
+      end
+    end
+  end
+
+  def test_after_context_float
+    @after = nil
+    opt = OptProc::Option.new(:tags => %w{ --after-context -A },
+                              :arg  => [ :required, :float ],
+                              :set  => Proc.new { |val| @after = val })
+    [ 
+      %w{ --after-context 3 },
+      %w{ --after-context=3 },
+      %w{ -A              3 },
+    ].each do |args|
+      @after = nil
+
+      m = opt.match(args)
+      assert_equal 1.0, m, "args: #{args.inspect}"
+      # curr = args.shift
+      opt.set_value(args)
+      assert_equal 3.0, @after
+    end
+  end
+
+  def test_regexp_option
+    @after = nil
+    opt = OptProc::Option.new(:res  => %r{ ^ - ([1-9]\d*) $ }x,
+                              :tags => %w{ --context -C },
+                              :arg  => [ :optional, :integer ],
+                              :set  => Proc.new { |val| @ctx = val })
+    [ 
+      %w{ --context 3 },
+      %w{ --context=3 },
+      %w{ -C        3 },
+    ].each do |args|
+      @ctx = nil
+
+      m = opt.match(args)
+      assert_equal 1.0, m, "args: #{args.inspect}"
+      opt.set_value(args)
+      assert_equal 3, @ctx
+    end
+
+    vals = (1 .. 10).to_a  | (1 .. 16).collect { |x| 2 ** x }
+    # vals = [ 4 ]
+    vals.each do |val|
+      args = [ '-' + val.to_s, 'foo' ]
+
+      @ctx = nil
+
+      m = opt.match(args)
+      assert_equal 1.0, m, "args: #{args.inspect}"
+      opt.set_value(args)
+      assert_equal val, @ctx
+    end
+  end
+
+  def test_value_regexp
+    @range_start = nil
+    opt = OptProc::Option.new(:tags    => %w{ --after },
+                              :arg     => [ :required, :regexp, %r{ ^ (\d+%?) $ }x ],
+                              :set     => Proc.new { |md| @range_start = md[1] })
+    
+    %w{ 5 5% 10 90% }.each do |rg|
+      [
+        [ '--after',   rg ],
+        [ '--after=' + rg ]
+      ].each do |args|
+        @range_start = nil
+        
+        m = opt.match(args)
+        assert_equal 1.0, m, "args: #{args.inspect}"
+        opt.set_value(args)
+        assert_equal rg, @range_start
+      end
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+  Log.level = Log::DEBUG
+end

data/test/riel/pathname_test.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/pathname'
+
+
+class PathnameTestCase < RUNIT::TestCase
+
+  def do_rootname_test(exp, path)
+    pn = Pathname.new(path)
+    assert_equals(exp, pn.rootname)
+  end
+
+  def test_rootname
+    [
+      "/this/is/a.test",
+      "/a.test",
+      "a.test",
+      "/this/is/a",
+      "/a",
+      "a"
+    ].each do |path|
+      do_rootname_test("a", path)
+    end
+
+    [
+      "/this/is/.atest",
+      "/.atest",
+      ".atest"
+    ].each do |path|
+      do_rootname_test(".atest",  path)
+    end
+  end
+
+end

data/test/riel/rcfile_test.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/rcfile'
+require 'riel/tempfile'
+
+class RCFileTestCase < RUNIT::TestCase
+  
+  def test
+    separators = %w{ = : }
+    leading_spaces = [ "", " ", "  " ]
+    trailing_spaces = leading_spaces.dup
+    comments = [ "", "# a comment" ]
+    
+    num = 0
+    tempfile = Tempfile.open("rcfile_test") do |tf|
+      
+      tf.puts "# this is a comment"
+      tf.puts ""
+      
+      separators.each do |sep|
+        leading_spaces.each do |lsp|
+          trailing_spaces.each do |tsp|
+            comments.each do |cmt|
+              tf.puts "#{lsp}name#{num}#{sep}value#{num}#{tsp}#{cmt}"
+              num += 1
+            end
+          end
+        end
+      end
+    end
+      
+    rc = RCFile.new(tempfile)
+    (0 ... num).each do |i|
+      key = "name#{i}"
+      assert_not_nil rc.settings[i]
+      pair = rc.settings[i]
+      
+      assert_equals [ "name#{i}", "value#{i}" ], rc.settings[i]
+    end
+  end
+
+end

data/test/riel/regexp_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/regexp'
+
+class RegexpTestCase < RUNIT::TestCase
+  
+  def test_unixre_to_string
+    assert_equal("a[b-z]",    Regexp.unixre_to_string("a[b-z]"))
+    assert_equal("ab\\.z",    Regexp.unixre_to_string("ab.z"))
+    assert_equal("ab\\.z.*",  Regexp.unixre_to_string("ab.z*"))
+    assert_equal("a.c",       Regexp.unixre_to_string("a?c"))
+    assert_equal("ab\\$",     Regexp.unixre_to_string("ab$"))
+    assert_equal("a\\/c",     Regexp.unixre_to_string("a/c"))
+    assert_equal("a\\(bc\\)", Regexp.unixre_to_string("a(bc)"))
+  end
+  
+  def test_negated
+    assert(NegatedRegexp.new("a[b-z]").match("aa"))
+    assert(NegatedRegexp.new(".+").match(""))
+  end
+
+end

data/test/riel/setdiff_test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/setdiff'
+
+class SetDiffTestCase < RUNIT::TestCase
+
+  def do_test(a, b, expected)
+    sd = SetDiff.new(a, b)
+
+    assert_equal(expected, sd.diff_type)
+  end
+
+  def test_all
+    do_test(%w{ one two three }, %w{ two one three },  :identical)
+    do_test(%w{ one two },       %w{ two one three },  :b_contains_a)
+    do_test(%w{ one two three }, %w{ two },            :a_contains_b)
+    do_test(%w{ one two three }, %w{ four five six },  :no_common)
+    do_test(%w{ one two three }, %w{ },                :no_common)
+    do_test(%w{ },               %w{ one two three },  :no_common)
+    do_test(%w{ },               %w{ },                :no_common)
+    do_test(%w{ one two three},  %w{ two three four }, :common)
+  end
+    
+end

data/test/riel/size_converter_test.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/size_converter'
+
+class SizeConverterTestCase < RUNIT::TestCase
+
+  SIZES = [
+    # 0123456789012345 0123456789012345 0123456789012345 0123456789012345 0123456789012345 0123456789012345 0123456789012345 
+    # base10.0         base10.1         base10.2         si.0             si.1             si.2             num              ]
+    [ "1",             "1.0",           "1.00",          "1",             "1.0",           "1.00",          1                ],
+
+    [ "1K",            "1.0K",          "1.02K",         "1KiB",          "1.0KiB",        "1.00KiB",       1024             ],
+    [ "1K",            "1.0K",          "1.00K",         "1000",          "1000.0",        "1000.00",       1000             ],
+    [ "2K",            "2.0K",          "2.05K",         "2KiB",          "2.0KiB",        "2.00KiB",       2048             ],
+    [ "2K",            "2.0K",          "2.00K",         "2KiB",          "2.0KiB",        "1.95KiB",       2000             ],
+
+    [ "1M",            "1.0M",          "1.00M",         "977KiB",        "976.6KiB",      "976.56KiB",     10 ** 6          ],
+    [ "2M",            "2.0M",          "2.00M",         "2MiB",          "1.9MiB",        "1.91MiB",       2 * 10 ** 6      ],
+    [ "1M",            "1.0M",          "1.05M",         "1MiB",          "1.0MiB",        "1.00MiB",       2 ** 20          ],
+    [ "2M",            "2.1M",          "2.10M",         "2MiB",          "2.0MiB",        "2.00MiB",       2 * 2 ** 20      ],
+
+    [ "1G",            "1.0G",          "1.00G",         "954MiB",        "953.7MiB",      "953.67MiB",     10 ** 9          ],
+    [ "2G",            "2.0G",          "2.00G",         "2GiB",          "1.9GiB",        "1.86GiB",       2 * 10 ** 9      ],
+
+    [ "1G",            "1.1G",          "1.07G",         "1GiB",          "1.0GiB",        "1.00GiB",       2 ** 30          ],
+    [ "2G",            "2.1G",          "2.15G",         "2GiB",          "2.0GiB",        "2.00GiB",       2 * 2 ** 30      ],
+
+    [ "1T",            "1.0T",          "1.00T",         "931GiB",        "931.3GiB",      "931.32GiB",     10 ** 12         ],
+    [ "2T",            "2.0T",          "2.00T",         "2TiB",          "1.8TiB",        "1.82TiB",       2 * 10 ** 12     ],
+
+    [ "1T",            "1.1T",          "1.10T",         "1TiB",          "1.0TiB",        "1.00TiB",       2 ** 40          ],
+    [ "2T",            "2.2T",          "2.20T",         "2TiB",          "2.0TiB",        "2.00TiB",       2 * 2 ** 40      ],
+  ]
+
+  def assert_conversion(cls, data, offset, didx, sidx, dec_places = nil)
+    numstr  = data[-1]
+    conv    = dec_places.nil? ? cls.convert(numstr) : cls.convert(numstr, dec_places)
+    assert_equals data[offset + didx], conv, "size index: #{sidx}; data index: #{didx}; offset: #{offset}; decimal_places: #{dec_places}"
+  end
+
+  def do_test(cls, offset)
+    SIZES.each_with_index do |data, sidx|
+      assert_conversion(cls, data, offset, 1, sidx)
+      (0 .. 2).each do |dec_places|
+        assert_conversion(cls, data, offset, dec_places, sidx, dec_places)
+      end
+    end
+  end
+
+  def test_default
+    do_test(SizeConverter, 0)
+  end
+
+  def test_human
+    do_test(SizeConverter::Human, 0)
+  end
+
+  def test_si
+    do_test(SizeConverter::SI, 3)
+  end
+
+end

data/test/riel/string_test.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+require 'rubyunit'
+require 'riel/string'
+
+class StringToRangeTestCase < RUNIT::TestCase
+
+  def do_string_to_range_test(exp, str, args = Hash.new)
+    String.to_ranges(str, args).each_with_index do |rg, idx|
+      assert_equal exp[idx], rg
+    end
+  end
+
+  def test_string_to_range
+    do_string_to_range_test([          ],                                       "")
+    do_string_to_range_test([  1 ..  1 ],                                       "1")
+    do_string_to_range_test([  1 ..  2 ],                                       "1..2")
+    do_string_to_range_test([  1 ..  1, 2 .. 2 ],                               "1,2")
+    do_string_to_range_test([  1 ..  2 ],                                       "1,2",               :collapse => true)
+
+    do_string_to_range_test([  1 ..  4 ],                                       "1-4")
+    do_string_to_range_test([ -String::Infinity ..  4 ],                        "-4")
+    do_string_to_range_test([ 4 .. String::Infinity ],                          "4-")
+
+    do_string_to_range_test([ -8 ..  4 ],                                       "-4",                :min => -8)
+    do_string_to_range_test([  0 ..  4 ],                                       "-4",                :min => 0)
+    do_string_to_range_test([  1 ..  8 ],                                       "1-",                :min => 0, :max => 8)
+    do_string_to_range_test([  1 ..  5 ],                                       "1-4,5",             :collapse => true)
+    do_string_to_range_test([  1 ..  4, 5 .. 5 ],                               "1-4,5",             :collapse => false)
+    do_string_to_range_test([  1 ..  4, 5 .. 5 ],                               "1-4,5")
+    do_string_to_range_test([  1 ..  3, 5 .. 8 ],                               "1,2,3,5-",          :min => 0, :max => 8, :collapse => true)
+    do_string_to_range_test([  1 ..  1, 2 .. 2, 3 .. 3, 5 .. 8 ],               "1,2,3,5-",          :min => 0, :max => 8)
+    do_string_to_range_test([  1 ..  3, 5 .. 6 ],                               "1-3,5,6",           :min => 0, :max => 8, :collapse => true)
+    do_string_to_range_test([  1 ..  3, 5 .. 5, 6 .. 6 ],                       "1-3,5,6",           :min => 0, :max => 8)
+    do_string_to_range_test([  1 ..  3, 5 .. 6, 10 .. 12 ],                     "1-3,5-6,10,11,12,", :collapse => true)
+    do_string_to_range_test([  1 ..  3, 5 .. 6, 10 .. 10, 11 .. 11, 12 .. 12 ], "1-3,5-6,10,11,12,")
+    
+    do_string_to_range_test([ ],                                                "abc")
+  end
+
+  def test_num
+    assert_equals(1,   "1".num)
+    assert_equals(nil, "one".num)
+  end
+
+  def test_minus
+    assert_equals("foo", "food" - "d")
+    assert_equals("fd",  "food" - %r{o+})
+  end
+
+  def test_highlight
+    assert_equals("...\e[34mthis\e[0m... is blue", "...this... is blue".highlight(%r{this}, "blue"))
+    assert_equals("...\e[34m\e[42mthis\e[0m... is blue", "...this... is blue".highlight(%r{this}, "blue on green"))
+  end
+
+end

data/test/riel/tempfile_test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/tempfile'
+
+class TempfileTestCase < RUNIT::TestCase
+
+  def test
+    tfname = Tempfile.open("tempfile_test") do |tf|
+    end
+
+    assert_not_nil tfname
+  end
+
+end

data/test/riel/text_test.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/text'
+
+class TextTestCase < RUNIT::TestCase
+
+  def do_ansi_test(str, input, *chars)
+    escape_sequence = chars.collect { |ch| "\e[#{ch}m" }.join("")
+    assert_equals "#{escape_sequence}#{str}\e[0m", input
+  end
+  
+  def test_ansi_highlight
+    String.highlighter = "ANSI"
+
+    str = "precision"
+
+    do_ansi_test(str, str.none,           0)
+    do_ansi_test(str, str.bold,           1)
+    do_ansi_test(str, str.underline,      4)
+    do_ansi_test(str, str.underscore,     4)
+    do_ansi_test(str, str.blink,          5) # every geocities site circa 1998
+    do_ansi_test(str, str.negative,       7)
+    do_ansi_test(str, str.concealed,      8)
+    do_ansi_test(str, str.black,         30)
+    do_ansi_test(str, str.red,           31)
+    do_ansi_test(str, str.green,         32)
+    do_ansi_test(str, str.yellow,        33)
+    do_ansi_test(str, str.blue,          34)
+    do_ansi_test(str, str.magenta,       35)
+    do_ansi_test(str, str.cyan,          36)
+    do_ansi_test(str, str.white,         37)
+    do_ansi_test(str, str.on_black,      40)
+    do_ansi_test(str, str.on_red,        41)
+    do_ansi_test(str, str.on_green,      42)
+    do_ansi_test(str, str.on_yellow,     43)
+    do_ansi_test(str, str.on_blue,       44)
+    do_ansi_test(str, str.on_magenta,    45)
+    do_ansi_test(str, str.on_cyan,       46)
+    do_ansi_test(str, str.on_white,      47)
+    do_ansi_test(str, str.none_on_white,  0, 47)
+    do_ansi_test(str, str.none_on_black,  0, 40)
+    do_ansi_test(str, str.none_on_blue,   0, 44)
+    do_ansi_test(str, str.red_on_white,  31, 47)
+    do_ansi_test(str, str.bold_red_on_white,  1, 31, 47)
+
+  end
+
+  def do_html_test(expected, input)
+    assert_equals expected, input
+  end
+  
+  def test_html_highlight
+    String.highlighter = "HTML"
+
+    str = "precision"
+
+    do_html_test(str, str.none)
+    do_html_test("<b>" + str + "</b>", str.bold)
+
+    [ str.underline, str.underscore ].each do |input|
+      do_html_test("<u>" + str + "</u>", input)
+    end
+
+    do_html_test("<blink>" + str + "</blink>", str.blink)
+    do_html_test("<span style=\"color: white; background-color: black\">" + str + "</span>", str.negative)
+    do_html_test("<!-- " + str + " -->", str.concealed)
+    do_html_test("<span style=\"color: black\">" + str + "</span>", str.black)
+    do_html_test("<span style=\"color: red\">" + str + "</span>", str.red)
+    do_html_test("<span style=\"color: green\">" + str + "</span>", str.green)
+    do_html_test("<span style=\"color: yellow\">" + str + "</span>", str.yellow)
+    do_html_test("<span style=\"color: blue\">" + str + "</span>", str.blue)
+    do_html_test("<span style=\"color: #FF00FF\">" + str + "</span>", str.magenta)
+    do_html_test("<span style=\"color: #00FFFF\">" + str + "</span>", str.cyan)
+    do_html_test("<span style=\"color: white\">" + str + "</span>", str.white)
+    do_html_test("<span style=\"background-color: black\">" + str + "</span>", str.on_black)
+    do_html_test("<span style=\"background-color: red\">" + str + "</span>", str.on_red)
+    do_html_test("<span style=\"background-color: green\">" + str + "</span>", str.on_green)
+    do_html_test("<span style=\"background-color: yellow\">" + str + "</span>", str.on_yellow)
+    do_html_test("<span style=\"background-color: blue\">" + str + "</span>", str.on_blue)
+    do_html_test("<span style=\"background-color: #FF00FF\">" + str + "</span>", str.on_magenta)
+    do_html_test("<span style=\"background-color: #00FFFF\">" + str + "</span>", str.on_cyan)
+    do_html_test("<span style=\"background-color: white\">" + str + "</span>", str.on_white)
+    do_html_test("<span style=\"background-color: white\">" + str + "</span>", str.none_on_white)
+    do_html_test("<span style=\"background-color: black\">" + str + "</span>", str.none_on_black)
+    do_html_test("<span style=\"background-color: blue\">" + str + "</span>", str.none_on_blue)
+    do_html_test("<span style=\"color: red\">" + "<span style=\"background-color: white\">" + str + "</span>" + "</span>", str.red_on_white)
+    do_html_test("<b><span style=\"color: red\">" + "<span style=\"background-color: white\">" + str + "</span>" + "</span></b>", str.bold_red_on_white)
+
+  end
+  
+  def test_string_reverse
+    String.highlighter = "HTML"
+
+    str = "precision"
+
+    # this tests that string.reverse does not mean ANSI reverse
+    assert_equal("noisicerp", "precision".reverse)
+  end
+
+end

data/test/riel/timer_test.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubyunit'
+require 'riel/timer'
+require 'stringio'
+
+class TimerTestCase < RUNIT::TestCase
+
+  TIMER_STRING = "sleep for a second"
+
+  def do_assertions(io)
+    assert_not_nil io
+    str = io.string
+    assert_not_nil str
+
+    assert str.index(TIMER_STRING + " start time:")
+    assert str.index(TIMER_STRING + " end   time:")
+    assert str.index(TIMER_STRING + " elapsed   :")
+  end
+
+  def test_to_stdout
+    orig_out = $stdout
+    $stdout  = StringIO.new
+    timer = Timer.new(TIMER_STRING) do
+      sleep(0.1)
+    end
+
+    do_assertions($stdout)
+    
+    $stdout  = orig_out
+  end
+  
+  def test_to_io
+    stringio = StringIO.new
+    timer = Timer.new("sleep for a second", :io => stringio) do
+      sleep(0.1)
+    end
+
+    do_assertions(stringio)
+  end
+
+end