extensions 0.4.0

data/test/tc_class.rb

@@ -0,0 +1,34 @@
+
+require 'test/unit'
+require 'extensions/class'
+
+class TC_Class < Test::Unit::TestCase
+
+  class ClassExample1
+    attr_reader :a, :b, :c
+    autoinit(:a, :b) do
+      @c = @a + @b
+    end
+  end
+
+  # Test autoinit with a block.
+  def test_autoinit_1
+    eg = ClassExample1.new(15, 3)
+    assert_equal(15, eg.a)
+    assert_equal(3,  eg.b)
+    assert_equal(18, eg.c)
+  end
+
+  class ClassExample2
+    attr_reader :x
+    autoinit(:x)
+  end
+
+  # Test autoinit without a block.
+  def test_autoinit_2
+    eg = ClassExample2.new("Hello")
+    assert_equal("Hello", eg.x)
+  end
+
+end  # class TC_Class
+

data/test/tc_enumerable.rb

@@ -0,0 +1,87 @@
+
+require 'test/unit'
+require 'extensions/enumerable'
+require 'set'
+
+class TC_Enumerable < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_build_hash
+    input = [1, 2, 3]
+    expected_output = { 1 => 1, 4 => 8, 9 => 27 }
+    output = input.build_hash { |n| [n**2, n**3] }
+    assert_equal(expected_output, output)
+
+    input = { "x" => 1, "y" => 2 }
+    expected_output = { :x => 1, :y => 2 }
+    output = input.build_hash { |a,b| [a.intern, b] }
+    assert_equal(expected_output, output)
+
+    input = [[1,1], [2,2]]
+    expected_output = { 1 => 1, 2 => 2 }
+    output = input.build_hash { |a,b| [a, b] }
+    assert_equal(expected_output, output)
+  end
+
+  def test_mapf
+    assert_equal([1,2,3], %w[1 2 3].mapf(:to_i))
+    assert_equal(%w[John Terry Fiona], %w[john terry fiona].mapf(:capitalize))
+  end
+
+  def test_collectf
+    assert_equal([1,2,3], %w[1 2 3].collectf(:to_i))
+    assert_equal(%w[John Terry Fiona], %w[john terry fiona].collectf(:capitalize))
+  end
+
+  def test_includes
+    assert([1, 2, 3].includes?(2))
+    assert("one\ntwo\nthree\n".includes?(5) == false)
+    assert({:t => 5, :u => 10, :e => 51}.includes?([:u, 10]))
+  end
+
+  def test_contains
+    assert([1, 2, 3].contains?(2))
+    assert("one\ntwo\nthree\n".contains?(5) == false)
+    assert({:t => 5, :u => 10, :e => 51}.contains?([:u, 10]))
+  end
+
+  def test_has
+    assert([1, 2, 3].has?(2))
+    assert("one\ntwo\nthree\n".has?(5) == false)
+    assert("one\ntwo\nthree\n".has?("two\n"))
+    assert({:t => 5, :u => 10, :e => 51}.has?([:u, 10]))
+  end
+
+  def test_map_with_index
+    columns = [ ["EMP_ID","INTEGER"], ["DIVISION", "CHAR(10)"] ]
+    data = ["11", "Retail"]
+    string_data = columns.map_with_index { |c, i|
+      col, type = c
+      datum = data[i]
+      datum = "'#{datum}'" if type =~ /char/i
+      datum
+    }
+    expected_output = ["11", "'Retail'"]
+    assert_equal(expected_output, string_data)
+  end
+
+  def test_partition_by
+    assert_equal({}, [].partition_by { |x| x })
+    
+    result = (1..5).partition_by { |n| n % 3 } 
+    expected_result = { 0 => [3], 1 => [1, 4], 2 => [2,5] } 
+    assert_equal(expected_result, result)
+  
+    result = ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
+    expected_result = { String => ["I had","dollar and","cents"], Fixnum => [1,50] } 
+    assert_equal(expected_result, result)
+  end
+
+  # Object#in? is tested in tc_object.rb.
+
+end  # class TC_Enumerable
+

data/test/tc_hash.rb

@@ -0,0 +1,34 @@
+
+require 'test/unit'
+require 'extensions/hash'
+
+class TC_Hash < Test::Unit::TestCase
+  def test_select!
+      # Empty hash.
+    a = {}
+    assert_equal(nil, a.select! {false}, "return nil if hash not changed")
+    assert_equal({}, a, "hash is not changed")
+
+    a = {}
+    assert_equal(nil, a.select! {true}, "return nil if hash not changed")
+    assert_equal({}, a, "hash is not changed")
+
+      # Non-empty hash.
+    a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
+    assert_equal({0 => 'a', 2 => 'c'}, a.select! {|x,y| x % 2 == 0}, "select even numbers")
+    assert_equal({0 => 'a', 2 => 'c'}, a, "select even numbers")
+
+    a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
+    assert_equal({1 => 'b'}, a.select! {|x,y| y == 'b'}, "select one member")
+    assert_equal({1 => 'b'}, a, "select one member")
+
+    a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
+    assert_equal(nil, a.select! {true}, "return nil if hash not changed")
+    assert_equal({0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}, a, "select all")
+
+    a = {0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'}
+    assert_equal({}, a.select! {false}, "select none")
+    assert_equal({}, a, "select none")
+  end
+end  # class TC_Hash
+

data/test/tc_io.rb

@@ -0,0 +1,32 @@
+
+require 'test/unit'
+require 'extensions/io'
+require 'tempfile'
+
+class TC_IO < Test::Unit::TestCase
+
+  def setup
+    tmp_dir = ENV["TMP"] || ENV["TEMP"] || "/tmp"
+    raise "Can't find TMP directory" unless File.directory?(tmp_dir)
+    @path = File.join(tmp_dir, "ruby_io_test")
+  end
+
+  # Test IO.write
+  def test_io_write
+    data_in = "Test data\n"
+    nbytes = File.write(@path, data_in)
+    data_out = File.read(@path)          # This is standard class method.
+    assert_equal(data_in, data_out)
+    assert_equal(data_out.size, nbytes)
+  end
+
+  # Test IO.writelines
+  def test_io_writelines
+    data_in = %w[one two three four five]
+    File.writelines(@path, data_in)
+    data_out = File.readlines(@path)     # This is standard class method.
+    assert_equal(data_in, data_out.map { |l| l.chomp })
+  end
+
+end
+

data/test/tc_numeric.rb

@@ -0,0 +1,435 @@
+
+require 'test/unit'
+require 'extensions/numeric'
+
+class TC_Numeric < Test::Unit::TestCase
+  def test_even
+    (-100..100).step(2) do |n|
+      assert(n.even? == true)
+    end
+    (-101..101).step(2) do |n|
+      assert(n.even? == false)
+    end
+  end
+
+  def test_odd
+    (-101..101).step(2) do |n|
+      assert(n.odd? == true)
+    end
+    (-100..100).step(2) do |n|
+      assert(n.odd? == false)
+    end
+  end
+end  # class TC_Numeric
+
+# Part of Austin Ziegler's code; see copyright notice above.
+class TC_FormatNumber < Test::Unit::TestCase
+  def test_integer
+    assert_equal("1", 1.format_s(:us))
+    assert_equal("12", 12.format_s(:us))
+    assert_equal("123", 123.format_s(:us))
+    assert_equal("1,234", 1234.format_s(:us))
+    assert_equal("12,345", 12345.format_s(:us))
+    assert_equal("123,456", 123456.format_s(:us))
+    assert_equal("1,234,567", 1234567.format_s(:us))
+    assert_equal("12,345,678", 12345678.format_s(:us))
+    assert_equal("123,456,789", 123456789.format_s(:us))
+    assert_equal("1,234,567,890", 1234567890.format_s(:us))
+    assert_equal("1", 1.format_s)
+    assert_equal("12", 12.format_s)
+    assert_equal("123", 123.format_s)
+    assert_equal("1,234", 1234.format_s)
+    assert_equal("12,345", 12345.format_s)
+    assert_equal("123,456", 123456.format_s)
+    assert_equal("1,234,567", 1234567.format_s)
+    assert_equal("12,345,678", 12345678.format_s)
+    assert_equal("123,456,789", 123456789.format_s)
+    assert_equal("1,234,567,890", 1234567890.format_s)
+  end
+
+  def test_usd_integer
+    assert_equal("$1", 1.format_s(:usd))
+    assert_equal("$12", 12.format_s(:usd))
+    assert_equal("$123", 123.format_s(:usd))
+    assert_equal("$1,234", 1234.format_s(:usd))
+    assert_equal("$12,345", 12345.format_s(:usd))
+    assert_equal("$123,456", 123456.format_s(:usd))
+    assert_equal("$1,234,567", 1234567.format_s(:usd))
+    assert_equal("$12,345,678", 12345678.format_s(:usd))
+    assert_equal("$123,456,789", 123456789.format_s(:usd))
+    assert_equal("$1,234,567,890", 1234567890.format_s(:usd))
+  end
+
+  def test_percent_integer
+    assert_equal("1%", 1.format_s(:percent))
+    assert_equal("12%", 12.format_s(:percent))
+    assert_equal("123%", 123.format_s(:percent))
+    assert_equal("1,234%", 1234.format_s(:percent))
+    assert_equal("12,345%", 12345.format_s(:percent))
+    assert_equal("123,456%", 123456.format_s(:percent))
+    assert_equal("1,234,567%", 1234567.format_s(:percent))
+    assert_equal("12,345,678%", 12345678.format_s(:percent))
+    assert_equal("123,456,789%", 123456789.format_s(:percent))
+    assert_equal("1,234,567,890%", 1234567890.format_s(:percent))
+  end
+
+  def test_euro_integer
+    assert_equal("�1", 1.format_s(:euro))
+    assert_equal("�12", 12.format_s(:euro))
+    assert_equal("�123", 123.format_s(:euro))
+    assert_equal("�1 234", 1234.format_s(:euro))
+    assert_equal("�12 345", 12345.format_s(:euro))
+    assert_equal("�123 456", 123456.format_s(:euro))
+    assert_equal("�1 234 567", 1234567.format_s(:euro))
+    assert_equal("�12 345 678", 12345678.format_s(:euro))
+    assert_equal("�123 456 789", 123456789.format_s(:euro))
+    assert_equal("�1 234 567 890", 1234567890.format_s(:euro))
+  end
+
+  def test_negative_integer
+    assert_equal("-1", -1.format_s(:us))
+    assert_equal("-12", -12.format_s(:us))
+    assert_equal("-123", -123.format_s(:us))
+    assert_equal("-1,234", -1234.format_s(:us))
+    assert_equal("-12,345", -12345.format_s(:us))
+    assert_equal("-123,456", -123456.format_s(:us))
+    assert_equal("-1,234,567", -1234567.format_s(:us))
+    assert_equal("-12,345,678", -12345678.format_s(:us))
+    assert_equal("-123,456,789", -123456789.format_s(:us))
+    assert_equal("-1,234,567,890", -1234567890.format_s(:us))
+    assert_equal("-1", -1.format_s)
+    assert_equal("-12", -12.format_s)
+    assert_equal("-123", -123.format_s)
+    assert_equal("-1,234", -1234.format_s)
+    assert_equal("-12,345", -12345.format_s)
+    assert_equal("-123,456", -123456.format_s)
+    assert_equal("-1,234,567", -1234567.format_s)
+    assert_equal("-12,345,678", -12345678.format_s)
+    assert_equal("-123,456,789", -123456789.format_s)
+    assert_equal("-1,234,567,890", -1234567890.format_s)
+  end
+
+  def test_negative_usd_integer
+    assert_equal("$-1", -1.format_s(:usd))
+    assert_equal("$-12", -12.format_s(:usd))
+    assert_equal("$-123", -123.format_s(:usd))
+    assert_equal("$-1,234", -1234.format_s(:usd))
+    assert_equal("$-12,345", -12345.format_s(:usd))
+    assert_equal("$-123,456", -123456.format_s(:usd))
+    assert_equal("$-1,234,567", -1234567.format_s(:usd))
+    assert_equal("$-12,345,678", -12345678.format_s(:usd))
+    assert_equal("$-123,456,789", -123456789.format_s(:usd))
+    assert_equal("$-1,234,567,890", -1234567890.format_s(:usd))
+  end
+
+  def test_negative_percent_integer
+    assert_equal("-1%", -1.format_s(:percent))
+    assert_equal("-12%", -12.format_s(:percent))
+    assert_equal("-123%", -123.format_s(:percent))
+    assert_equal("-1,234%", -1234.format_s(:percent))
+    assert_equal("-12,345%", -12345.format_s(:percent))
+    assert_equal("-123,456%", -123456.format_s(:percent))
+    assert_equal("-1,234,567%", -1234567.format_s(:percent))
+    assert_equal("-12,345,678%", -12345678.format_s(:percent))
+    assert_equal("-123,456,789%", -123456789.format_s(:percent))
+    assert_equal("-1,234,567,890%", -1234567890.format_s(:percent))
+  end
+
+  def test_negative_euro_integer
+    assert_equal("�-1", -1.format_s(:euro))
+    assert_equal("�-12", -12.format_s(:euro))
+    assert_equal("�-123", -123.format_s(:euro))
+    assert_equal("�-1 234", -1234.format_s(:euro))
+    assert_equal("�-12 345", -12345.format_s(:euro))
+    assert_equal("�-123 456", -123456.format_s(:euro))
+    assert_equal("�-1 234 567", -1234567.format_s(:euro))
+    assert_equal("�-12 345 678", -12345678.format_s(:euro))
+    assert_equal("�-123 456 789", -123456789.format_s(:euro))
+    assert_equal("�-1 234 567 890", -1234567890.format_s(:euro))
+  end
+
+  def test_spaces
+    assert_equal("1", 1.format_s(:us, :sep => " "))
+    assert_equal("12", 12.format_s(:us, :sep => " "))
+    assert_equal("123", 123.format_s(:us, :sep => " "))
+    assert_equal("1 234", 1234.format_s(:us, :sep => " "))
+    assert_equal("12 345", 12345.format_s(:us, :sep => " "))
+    assert_equal("123 456", 123456.format_s(:us, :sep => " "))
+    assert_equal("1 234 567", 1234567.format_s(:us, :sep => " "))
+    assert_equal("12 345 678", 12345678.format_s(:us, :sep => " "))
+    assert_equal("123 456 789", 123456789.format_s(:us, :sep => " "))
+    assert_equal("1 234 567 890", 1234567890.format_s(:us, :sep => " "))
+  end
+
+  def test_negative_spaces
+    assert_equal("-1", -1.format_s(:us, :sep => " "))
+    assert_equal("-12", -12.format_s(:us, :sep => " "))
+    assert_equal("-123", -123.format_s(:us, :sep => " "))
+    assert_equal("-1 234", -1234.format_s(:us, :sep => " "))
+    assert_equal("-12 345", -12345.format_s(:us, :sep => " "))
+    assert_equal("-123 456", -123456.format_s(:us, :sep => " "))
+    assert_equal("-1 234 567", -1234567.format_s(:us, :sep => " "))
+    assert_equal("-12 345 678", -12345678.format_s(:us, :sep => " "))
+    assert_equal("-123 456 789", -123456789.format_s(:us, :sep => " "))
+    assert_equal("-1 234 567 890", -1234567890.format_s(:us, :sep => " "))
+  end
+
+  def test_size
+    assert_equal("1", 1.format_s(:us, :size => 2))
+    assert_equal("12", 12.format_s(:us, :size => 2))
+    assert_equal("1,23", 123.format_s(:us, :size => 2))
+    assert_equal("12,34", 1234.format_s(:us, :size => 2))
+    assert_equal("1,23,45", 12345.format_s(:us, :size => 2))
+    assert_equal("12,34,56", 123456.format_s(:us, :size => 2))
+    assert_equal("1,23,45,67", 1234567.format_s(:us, :size => 2))
+    assert_equal("12,34,56,78", 12345678.format_s(:us, :size => 2))
+    assert_equal("1,23,45,67,89", 123456789.format_s(:us, :size => 2))
+    assert_equal("12,34,56,78,90", 1234567890.format_s(:us, :size => 2))
+  end
+
+  def test_negative_size
+    assert_equal("-1", -1.format_s(:us, :size => 2))
+    assert_equal("-12", -12.format_s(:us, :size => 2))
+    assert_equal("-1,23", -123.format_s(:us, :size => 2))
+    assert_equal("-12,34", -1234.format_s(:us, :size => 2))
+    assert_equal("-1,23,45", -12345.format_s(:us, :size => 2))
+    assert_equal("-12,34,56", -123456.format_s(:us, :size => 2))
+    assert_equal("-1,23,45,67", -1234567.format_s(:us, :size => 2))
+    assert_equal("-12,34,56,78", -12345678.format_s(:us, :size => 2))
+    assert_equal("-1,23,45,67,89", -123456789.format_s(:us, :size => 2))
+    assert_equal("-12,34,56,78,90", -1234567890.format_s(:us, :size => 2))
+  end
+
+  def test_usd_decimal
+    assert_equal("$1.1", 1.1.format_s(:usd))
+    assert_equal("$12.12", 12.12.format_s(:usd))
+    assert_equal("$123.123", 123.123.format_s(:usd))
+    assert_equal("$1,234.1234", 1234.1234.format_s(:usd))
+    assert_equal("$12,345.12345", 12345.12345.format_s(:usd))
+    assert_equal("$123,456.123456", 123456.123456.format_s(:usd))
+    assert_equal("$1,234,567.1234567", 1234567.1234567.format_s(:usd))
+    assert_equal("$12,345,678.1234568", 12345678.12345678.format_s(:usd))
+    assert_equal("$123,456,789.123457", 123456789.123456789.format_s(:usd))
+    assert_equal("$1,234,567,890.01235", 1234567890.0123456789.format_s(:usd))
+  end
+
+  def test_percent_decimal
+    assert_equal("1.1%", 1.1.format_s(:percent))
+    assert_equal("12.12%", 12.12.format_s(:percent))
+    assert_equal("123.123%", 123.123.format_s(:percent))
+    assert_equal("1,234.1234%", 1234.1234.format_s(:percent))
+    assert_equal("12,345.12345%", 12345.12345.format_s(:percent))
+    assert_equal("123,456.123456%", 123456.123456.format_s(:percent))
+    assert_equal("1,234,567.1234567%", 1234567.1234567.format_s(:percent))
+    assert_equal("12,345,678.1234568%", 12345678.12345678.format_s(:percent))
+    assert_equal("123,456,789.123457%", 123456789.123456789.format_s(:percent))
+    assert_equal("1,234,567,890.01235%", 1234567890.0123456789.format_s(:percent))
+  end
+
+  def test_euro_decimal
+    assert_equal("�1,1", 1.1.format_s(:euro))
+    assert_equal("�12,12", 12.12.format_s(:euro))
+    assert_equal("�123,123", 123.123.format_s(:euro))
+    assert_equal("�1 234,1234", 1234.1234.format_s(:euro))
+    assert_equal("�12 345,12345", 12345.12345.format_s(:euro))
+    assert_equal("�123 456,123456", 123456.123456.format_s(:euro))
+    assert_equal("�1 234 567,1234567", 1234567.1234567.format_s(:euro))
+    assert_equal("�12 345 678,1234568", 12345678.12345678.format_s(:euro))
+    assert_equal("�123 456 789,123457", 123456789.123456789.format_s(:euro))
+    assert_equal("�1 234 567 890,01235", 1234567890.0123456789.format_s(:euro))
+  end
+
+  def test_decimal
+    assert_equal("1.1", 1.1.format_s(:us))
+    assert_equal("12.12", 12.12.format_s(:us))
+    assert_equal("123.123", 123.123.format_s(:us))
+    assert_equal("1,234.1234", 1234.1234.format_s(:us))
+    assert_equal("12,345.12345", 12345.12345.format_s(:us))
+    assert_equal("123,456.123456", 123456.123456.format_s(:us))
+    assert_equal("1,234,567.1234567", 1234567.1234567.format_s(:us))
+    assert_equal("12,345,678.1234568", 12345678.12345678.format_s(:us))
+    assert_equal("123,456,789.123457", 123456789.123456789.format_s(:us))
+    assert_equal("1,234,567,890.01235", 1234567890.0123456789.format_s(:us))
+    assert_equal("1.1", 1.1.format_s)
+    assert_equal("12.12", 12.12.format_s)
+    assert_equal("123.123", 123.123.format_s)
+    assert_equal("1,234.1234", 1234.1234.format_s)
+    assert_equal("12,345.12345", 12345.12345.format_s)
+    assert_equal("123,456.123456", 123456.123456.format_s)
+    assert_equal("1,234,567.1234567", 1234567.1234567.format_s)
+    assert_equal("12,345,678.1234568", 12345678.12345678.format_s)
+    assert_equal("123,456,789.123457", 123456789.123456789.format_s)
+    assert_equal("1,234,567,890.01235", 1234567890.0123456789.format_s)
+  end
+
+  def test_negative_decimal
+    assert_equal("-1.1", -1.1.format_s(:us))
+    assert_equal("-12.12", -12.12.format_s(:us))
+    assert_equal("-123.123", -123.123.format_s(:us))
+    assert_equal("-1,234.1234", -1234.1234.format_s(:us))
+    assert_equal("-12,345.12345", -12345.12345.format_s(:us))
+    assert_equal("-123,456.123456", -123456.123456.format_s(:us))
+    assert_equal("-1,234,567.1234567", -1234567.1234567.format_s(:us))
+    assert_equal("-12,345,678.1234568", -12345678.12345678.format_s(:us))
+    assert_equal("-123,456,789.123457", -123456789.123456789.format_s(:us))
+    assert_equal("-1,234,567,890.01235", -1234567890.0123456789.format_s(:us))
+  end
+
+  def test_negative_usd_decimal
+    assert_equal("$-1.1", -1.1.format_s(:usd))
+    assert_equal("$-12.12", -12.12.format_s(:usd))
+    assert_equal("$-123.123", -123.123.format_s(:usd))
+    assert_equal("$-1,234.1234", -1234.1234.format_s(:usd))
+    assert_equal("$-12,345.12345", -12345.12345.format_s(:usd))
+    assert_equal("$-123,456.123456", -123456.123456.format_s(:usd))
+    assert_equal("$-1,234,567.1234567", -1234567.1234567.format_s(:usd))
+    assert_equal("$-12,345,678.1234568", -12345678.12345678.format_s(:usd))
+    assert_equal("$-123,456,789.123457", -123456789.123456789.format_s(:usd))
+    assert_equal("$-1,234,567,890.01235", -1234567890.0123456789.format_s(:usd))
+  end
+
+  def test_negative_percent_decimal
+    assert_equal("-1.1%", -1.1.format_s(:percent))
+    assert_equal("-12.12%", -12.12.format_s(:percent))
+    assert_equal("-123.123%", -123.123.format_s(:percent))
+    assert_equal("-1,234.1234%", -1234.1234.format_s(:percent))
+    assert_equal("-12,345.12345%", -12345.12345.format_s(:percent))
+    assert_equal("-123,456.123456%", -123456.123456.format_s(:percent))
+    assert_equal("-1,234,567.1234567%", -1234567.1234567.format_s(:percent))
+    assert_equal("-12,345,678.1234568%", -12345678.12345678.format_s(:percent))
+    assert_equal("-123,456,789.123457%", -123456789.123456789.format_s(:percent))
+    assert_equal("-1,234,567,890.01235%", -1234567890.0123456789.format_s(:percent))
+  end
+
+  def test_negative_euro_decimal
+    assert_equal("�-1,1", -1.1.format_s(:euro))
+    assert_equal("�-12,12", -12.12.format_s(:euro))
+    assert_equal("�-123,123", -123.123.format_s(:euro))
+    assert_equal("�-1 234,1234", -1234.1234.format_s(:euro))
+    assert_equal("�-12 345,12345", -12345.12345.format_s(:euro))
+    assert_equal("�-123 456,123456", -123456.123456.format_s(:euro))
+    assert_equal("�-1 234 567,1234567", -1234567.1234567.format_s(:euro))
+    assert_equal("�-12 345 678,1234568", -12345678.12345678.format_s(:euro))
+    assert_equal("�-123 456 789,123457", -123456789.123456789.format_s(:euro))
+    assert_equal("�-1 234 567 890,01235", -1234567890.0123456789.format_s(:euro))
+  end
+
+  def test_european
+    assert_equal("1,1", 1.1.format_s(:eu))
+    assert_equal("12,12", 12.12.format_s(:eu))
+    assert_equal("123,123", 123.123.format_s(:eu))
+    assert_equal("1 234,1234", 1234.1234.format_s(:eu))
+    assert_equal("12 345,12345", 12345.12345.format_s(:eu))
+    assert_equal("123 456,123456", 123456.123456.format_s(:eu))
+    assert_equal("1 234 567,1234567", 1234567.1234567.format_s(:eu))
+    assert_equal("12 345 678,1234568", 12345678.12345678.format_s(:eu))
+    assert_equal("123 456 789,123457", 123456789.123456789.format_s(:eu))
+    assert_equal("1 234 567 890,01235", 1234567890.0123456789.format_s(:eu))
+  end
+
+  def test_negative_european
+    assert_equal("-1,1", -1.1.format_s(:eu))
+    assert_equal("-12,12", -12.12.format_s(:eu))
+    assert_equal("-123,123", -123.123.format_s(:eu))
+    assert_equal("-1 234,1234", -1234.1234.format_s(:eu))
+    assert_equal("-12 345,12345", -12345.12345.format_s(:eu))
+    assert_equal("-123 456,123456", -123456.123456.format_s(:eu))
+    assert_equal("-1 234 567,1234567", -1234567.1234567.format_s(:eu))
+    assert_equal("-12 345 678,1234568", -12345678.12345678.format_s(:eu))
+    assert_equal("-123 456 789,123457", -123456789.123456789.format_s(:eu))
+    assert_equal("-1 234 567 890,01235", -1234567890.0123456789.format_s(:eu))
+  end
+
+  def test_negative_accountant
+    assert_equal("(1.1)", -1.1.format_s(:us, :acct => true))
+    assert_equal("(12.12)", -12.12.format_s(:us, :acct => true))
+    assert_equal("(123.123)", -123.123.format_s(:us, :acct => true))
+    assert_equal("(1,234.1234)", -1234.1234.format_s(:us, :acct => true))
+    assert_equal("(12,345.12345)", -12345.12345.format_s(:us, :acct => true))
+    assert_equal("(123,456.123456)", -123456.123456.format_s(:us, :acct => true))
+    assert_equal("(1,234,567.1234567)", -1234567.1234567.format_s(:us, :acct => true))
+    assert_equal("(12,345,678.1234568)", -12345678.12345678.format_s(:us, :acct => true))
+    assert_equal("(123,456,789.123457)", -123456789.123456789.format_s(:us, :acct => true))
+    assert_equal("(1,234,567,890.01235)", -1234567890.0123456789.format_s(:us, :acct => true))
+  end
+
+  def test_negative_accountant_usd
+    assert_equal("$(1.1)", -1.1.format_s(:usd, :acct => true))
+    assert_equal("$(12.12)", -12.12.format_s(:usd, :acct => true))
+    assert_equal("$(123.123)", -123.123.format_s(:usd, :acct => true))
+    assert_equal("$(1,234.1234)", -1234.1234.format_s(:usd, :acct => true))
+    assert_equal("$(12,345.12345)", -12345.12345.format_s(:usd, :acct => true))
+    assert_equal("$(123,456.123456)", -123456.123456.format_s(:usd, :acct => true))
+    assert_equal("$(1,234,567.1234567)", -1234567.1234567.format_s(:usd, :acct => true))
+    assert_equal("$(12,345,678.1234568)", -12345678.12345678.format_s(:usd, :acct => true))
+    assert_equal("$(123,456,789.123457)", -123456789.123456789.format_s(:usd, :acct => true))
+    assert_equal("$(1,234,567,890.01235)", -1234567890.0123456789.format_s(:usd, :acct => true))
+  end
+
+  def test_negative_accountant_percent
+    assert_equal("(1.1)%", -1.1.format_s(:percent, :acct => true))
+    assert_equal("(12.12)%", -12.12.format_s(:percent, :acct => true))
+    assert_equal("(123.123)%", -123.123.format_s(:percent, :acct => true))
+    assert_equal("(1,234.1234)%", -1234.1234.format_s(:percent, :acct => true))
+    assert_equal("(12,345.12345)%", -12345.12345.format_s(:percent, :acct => true))
+    assert_equal("(123,456.123456)%", -123456.123456.format_s(:percent, :acct => true))
+    assert_equal("(1,234,567.1234567)%", -1234567.1234567.format_s(:percent, :acct => true))
+    assert_equal("(12,345,678.1234568)%", -12345678.12345678.format_s(:percent, :acct => true))
+    assert_equal("(123,456,789.123457)%", -123456789.123456789.format_s(:percent, :acct => true))
+    assert_equal("(1,234,567,890.01235)%", -1234567890.0123456789.format_s(:percent, :acct => true))
+  end
+
+  def test_negative_european_accountant_euro
+    assert_equal("�(1,1)",  -1.1.format_s(:euro, :acct => true))
+    assert_equal("�(12,12)",  -12.12.format_s(:euro, :acct => true))
+    assert_equal("�(123,123)",  -123.123.format_s(:euro, :acct => true))
+    assert_equal("�(1 234,1234)",  -1234.1234.format_s(:euro, :acct => true))
+    assert_equal("�(12 345,12345)",  -12345.12345.format_s(:euro, :acct => true))
+    assert_equal("�(123 456,123456)",  -123456.123456.format_s(:euro, :acct => true))
+    assert_equal("�(1 234 567,1234567)",  -1234567.1234567.format_s(:euro, :acct => true))
+    assert_equal("�(12 345 678,1234568)",  -12345678.12345678.format_s(:euro, :acct => true))
+    assert_equal("�(123 456 789,123457)",  -123456789.123456789.format_s(:euro, :acct => true))
+    assert_equal("�(1 234 567 890,01235)",  -1234567890.0123456789.format_s(:euro, :acct => true))
+  end
+
+  def test_negative_european_accountant
+    assert_equal("(1,1)",  -1.1.format_s(:eu, :acct => true))
+    assert_equal("(12,12)",  -12.12.format_s(:eu, :acct => true))
+    assert_equal("(123,123)",  -123.123.format_s(:eu, :acct => true))
+    assert_equal("(1 234,1234)",  -1234.1234.format_s(:eu, :acct => true))
+    assert_equal("(12 345,12345)",  -12345.12345.format_s(:eu, :acct => true))
+    assert_equal("(123 456,123456)",  -123456.123456.format_s(:eu, :acct => true))
+    assert_equal("(1 234 567,1234567)",  -1234567.1234567.format_s(:eu, :acct => true))
+    assert_equal("(12 345 678,1234568)",  -12345678.12345678.format_s(:eu, :acct => true))
+    assert_equal("(123 456 789,123457)",  -123456789.123456789.format_s(:eu, :acct => true))
+    assert_equal("(1 234 567 890,01235)",  -1234567890.0123456789.format_s(:eu, :acct => true))
+  end
+
+  def test_decimal_formatted
+    assert_equal("1.1", 1.1.format_s(:us, :fd => true))
+    assert_equal("12.12", 12.12.format_s(:us, :fd => true))
+    assert_equal("123.123", 123.123.format_s(:us, :fd => true))
+    assert_equal("1,234.123,4", 1234.1234.format_s(:us, :fd => true))
+    assert_equal("12,345.123,45", 12345.12345.format_s(:us, :fd => true))
+    assert_equal("123,456.123,456", 123456.123456.format_s(:us, :fd => true))
+    assert_equal("1,234,567.123,456,7", 1234567.1234567.format_s(:us, :fd => true))
+    assert_equal("12,345,678.123,456,8", 12345678.12345678.format_s(:us, :fd => true))
+    assert_equal("123,456,789.123,457", 123456789.123456789.format_s(:us, :fd => true))
+    assert_equal("1,234,567,890.012,35", 1234567890.0123456789.format_s(:us, :fd => true))
+  end
+
+  def test_negative_decimal_formatted
+    assert_equal("-1.1", -1.1.format_s(:us, :fd => true))
+    assert_equal("-12.12", -12.12.format_s(:us, :fd => true))
+    assert_equal("-123.123", -123.123.format_s(:us, :fd => true))
+    assert_equal("-1,234.123,4", -1234.1234.format_s(:us, :fd => true))
+    assert_equal("-12,345.123,45", -12345.12345.format_s(:us, :fd => true))
+    assert_equal("-123,456.123,456", -123456.123456.format_s(:us, :fd => true))
+    assert_equal("-1,234,567.123,456,7", -1234567.1234567.format_s(:us, :fd => true))
+    assert_equal("-12,345,678.123,456,8", -12345678.12345678.format_s(:us, :fd => true))
+    assert_equal("-123,456,789.123,457", -123456789.123456789.format_s(:us, :fd => true))
+    assert_equal("-1,234,567,890.012,35", -1234567890.0123456789.format_s(:us, :fd => true))
+  end
+
+end  # class TC_FormatNumber
+