facets 2.4.5 → 2.5.0

data/test/core/hash/test_update.rb

@@ -1,46 +0,0 @@
-require 'facets/hash/update'
-require 'test/unit'
-
-class TC_Hash_Prime < Test::Unit::TestCase
-
-  def test_shift_update
-    a = { :a => 1, :b => 2, :c => 3 }
-    b = { :a => 0, :d => 4 }
-    e = { :a => 0, :b => 2, :c => 3, :d => 4 }
-    assert_equal( e, a << b )
-  end
-
-  def test_update_each
-    a = { :a => 1, :b => 2, :c => 3 }
-    e = { :a => 2, :b => 3, :c => 4 }
-    a.update_each{ |k,v| { k => v+1 } }
-    assert_equal( e, a )
-  end
-
-  def test_update_keys_01
-    h = { 'A' => 1, 'B' => 2 }
-    h.update_keys{ |k| k.downcase }
-    assert_equal( { 'a' => 1, 'b' => 2 }, h)
-  end
-
-  def test_update_keys_02
-    h = { :a => 1, :b => 2 }
-    h.update_keys{ |k| "#{k}!" }
-    assert_equal( { "a!" => 1, "b!" => 2 }, h)
-  end
-
-  def test_update_values
-    h = { 1 => 'A', 2 => 'B' }
-    h.update_values{ |v| v.downcase }
-    assert_equal( { 1 => 'a', 2 => 'b' }, h )
-  end
-
-  def test_replace_each
-    a = { :a => 1, :b => 2, :c => 3 }
-    e = { :a => 2, :b => 3, :c => 4 }
-    a.replace_each{ |k,v| { k => v+1 } }
-    assert_equal( e, a )
-  end
-
-end
-

data/test/more/test_annotations.rb

@@ -1,120 +0,0 @@
-# Test for facets/annotations.rb
-
-require 'test/unit'
-require 'facets/annotations'
-
-class TestAnnotation1 < Test::Unit::TestCase
-  class X
-    def x1 ; end
-    ann :x1, :a=>1
-    ann :x1, :b=>2
-  end
-
-  def test_1_01
-    assert_equal( X.ann(:x1,:a), X.ann(:x1,:a) )
-    assert_equal( X.ann(:x1,:a).object_id, X.ann(:x1,:a).object_id )
-  end
-  def test_1_02
-    X.ann :x1, :a => 2
-    assert_equal( 2, X.ann(:x1,:a) )
-  end
-end
-
-class TestAnnotation2 < Test::Unit::TestCase
-  class X
-    def x1 ; end
-    ann :x1, :a=>1
-    ann :x1, :b=>2
-  end
-  class Y < X ; end
-
-  def test_2_01
-    assert_equal( Y.ann(:x1,:a), Y.ann(:x1,:a) )
-    assert_equal( Y.ann(:x1,:a).object_id, Y.ann(:x1,:a).object_id )
-  end
-  def test_2_02
-    assert_equal( 1, Y.ann(:x1,:a) )
-    assert_equal( 2, Y.ann(:x1,:b) )
-  end
-  def test_2_03
-    Y.ann :x1,:a => 2
-    assert_equal( 2, Y.ann(:x1,:a) )
-    assert_equal( 2, Y.ann(:x1,:b) )
-  end
-end
-
-class TestAnnotation3 < Test::Unit::TestCase
-  class X
-    ann :foo, Integer
-  end
-  class Y < X
-    ann :foo, String
-  end
-
-  def test_3_01
-    assert_equal( Integer, X.ann(:foo, :class) )
-  end
-  def test_3_02
-    assert_equal( String, Y.ann(:foo, :class) )
-  end
-end
-
-class TestAnnotation4 < Test::Unit::TestCase
-  class X
-    ann :foo, :doc => "hello"
-    ann :foo, :bar => []
-  end
-  class Y < X
-    ann :foo, :class => String, :doc => "bye"
-  end
-
-  def test_4_01
-    assert_equal( "hello", X.ann(:foo,:doc) )
-  end
-  def test_4_02
-    assert_equal( X.ann(:foo), { :doc => "hello", :bar => [] } )
-  end
-  def test_4_03
-    X.ann(:foo,:bar) << "1"
-    assert_equal( ["1"], X.ann(:foo,:bar) )
-  end
-  def test_4_04
-    assert_equal( "bye", Y.ann(:foo,:doc) )
-  end
-  def test_4_05
-    #assert_equal( nil, Y.ann(:foo,:bar) )
-    assert_equal( ["1"], Y.ann(:foo,:bar) )
-  end
-  def test_4_06
-    Y.ann(:foo, :doc => "cap")
-    assert_equal( "cap", Y.ann(:foo, :doc)  )
-  end
-  def test_4_07
-    Y.ann!(:foo,:bar) << "2"
-    assert_equal( ["1", "2"], Y.ann(:foo,:bar) )
-    assert_equal( ["1", "2"], Y.ann(:foo,:bar) )
-    assert_equal( ["1"], X.ann(:foo,:bar) )
-  end
-end
-
-class TC_Attributes_Using_Attr < Test::Unit::TestCase
-  class A
-    attr :x, :cast=>"to_s"
-  end
-
-  def test_01
-    assert_equal( "to_s", A.ann(:x,:cast) )
-  end
-end
-
-class TC_Attributes_Using_Attr_Accessor < Test::Unit::TestCase
-  class A
-    attr_accessor :x, :cast=>"to_s"
-  end
-
-  def test_01
-    a = A.new
-    assert_equal( [:x], A.instance_attributes )
-  end
-end
-

data/test/more/test_bytes.rb

@@ -1,71 +0,0 @@
-# Test lib/facets/bytes.rb
-
-require 'facets/bytes.rb'
-require 'test/unit'
-
-class TC_Numeric < Test::Unit::TestCase
-
-  # bits
-
-  def test_bits
-    assert_equal( 8, 8.bits )
-  end
-
-  def test_kilobits
-    assert_equal( 1024**1, 1.kilobit )
-  end
-
-  def test_megabits
-    assert_equal( 1024**2, 1.megabit )
-  end
-
-  def test_gigabits
-    assert_equal( 1024**3, 1.gigabit )
-  end
-
-  def test_terabits
-    assert_equal( 1024**4, 1.terabit )
-  end
-
-  # bytes
-
-  def test_bytes
-    assert_equal( 8192, 1024.bytes )
-  end
-
-  def test_kilobytes
-    assert_equal( 1024**1*8, 1.kilobyte )
-  end
-
-  def test_megabytes
-    assert_equal( 1024**2*8, 1.megabyte )
-  end
-
-  def test_gigabytes
-    assert_equal( 1024**3*8, 1.gigabyte )
-  end
-
-  def test_terabytes
-    assert_equal( 1024**4*8, 1.terabyte )
-  end
-
-  # bits_to_s
-
-  def test_strfbits
-    assert_equal( "1.00 kb", 1024.strfbits )
-    assert_equal( "1.00 mb", 1048576.strfbits )
-    assert_equal( "1.00 gb", 1073741824.strfbits )
-    assert_equal( "1.00 tb", 1099511627776.strfbits )
-  end
-
-  # bytes_to_s
-
-  def test_strfbytes
-    assert_equal( "1.00 KB", 1024.strfbytes )
-    assert_equal( "1.00 MB", 1048576.strfbytes )
-    assert_equal( "1.00 GB", 1073741824.strfbytes )
-    assert_equal( "1.00 TB", 1099511627776.strfbytes )
-  end
-
-end
-

data/test/more/test_command.rb

@@ -1,69 +0,0 @@
-require 'facets/command'
-require 'test/unit'
-
-class TC_Command_Simple < Test::Unit::TestCase
-
-  #
-  # Test simple, single funciton command.
-  #
-
-  class SimpleCommand < CLI::Command
-
-    def call
-      "hello"
-    end
-
-  end
-
-  def test_simple
-    assert_equal("hello", SimpleCommand.start)
-  end
-
-end
-
-#
-# Test dispatching commands (aka Master Commands).
-#
-
-class TC_Command_Dispatch < Test::Unit::TestCase
-
-  class ComplexCommand < CLI::Command
-
-    def sink
-      "sink"
-    end
-
-    def swim
-      "swim"
-    end
-
-  end
-
-  def test_complex
-    assert_equal("swim", ComplexCommand.start(['swim']))
-  end
-
-end
-
-#
-# Test subcommand convenience method.
-#
-
-class TC_Command_Subcommand < Test::Unit::TestCase
-
-  include Console
-
-  class SubCommand < CLI::Command
-    def call ; 'submarine' ; end
-  end
-
-  class ComplexCommand < CLI::Command
-    subcommand :submariner, SubCommand
-  end
-
-  def test_complex
-    assert_equal("submarine", ComplexCommand.start(['submariner']))
-  end
-
-end
-

data/test/more/test_times.rb

@@ -1,89 +0,0 @@
-# Test facets/times.rb
-
-require 'facets/times.rb'
-require 'test/unit'
-
-class TC_Times < Test::Unit::TestCase
-
-  #def test_micro_seconds
-  #  assert_equal( 0.000001, 1.microsecond )
-  #end
-
-  #def test_milli_seconds
-  #  assert_equal( 0.001, 1.millisecond )
-  #end
-
-  def test_seconds
-    assert_equal( 60**0, 1.seconds )
-  end
-
-  def test_minutes
-    assert_equal( 60**1, 1.minutes )
-  end
-
-  def test_hours
-    assert_equal( 60**2, 1.hours )
-  end
-
-  def test_days
-    assert_equal( 24*(60**2), 1.days )
-  end
-
-  def test_weeks
-    assert_equal( 7*24*(60**2), 1.weeks )
-  end
-
-  def test_fortnights
-    assert_equal( 14*24*(60**2), 1.fortnights )
-  end
-
-  def test_months
-    assert_equal( 30*24*(60**2), 1.months )
-  end
-
-  def test_years
-    assert_equal( 365*24*(60**2), 1.years )
-  end
-
-  def test_before
-    t = Time.now
-    assert_equal( t - 1.day, 1.day.before(t) )
-  end
-
-  def test_after
-    t = Time.now
-    assert_equal( t + 1.day, 1.day.after(t) )
-  end
-
-end
-
-class WeekdaysTest < Test::Unit::TestCase
-
-  MONDAY = Time.at(1165250000)
-  THURSDAY = Time.at(1165500000)
-  FRIDAY = Time.at(1165606025)
-
-  def test_weekday_after_monday
-    assert_equal 2, 1.weekday.since(MONDAY).wday
-  end
-
-  def test_weekday_after_friday
-    assert_equal 1, 1.weekday.after(FRIDAY).wday
-  end
-
-  def test_weekdays_before_friday
-    assert_equal 2, 3.weekdays.before(FRIDAY).wday
-  end
-
-  #def test_weekday_before_today
-  #  Time.expects(:now).returns(THURSDAY)
-  #  assert_equal 3, 1.weekday.ago.wday
-  #end
-
-  #def test_weekdays_after_today
-  #  Time.expects(:now).returns(MONDAY)
-  #  assert_equal 3, 2.weekday.from_now.wday
-  #end
-
-end
-