facets 2.8.4 → 2.9.0.pre.1

data/test/core/integer/test_length.rb

@@ -1,12 +0,0 @@
-require 'facets/integer/length'
-require 'test/unit'
-
-
-class TC_Integer < Test::Unit::TestCase
-  def test_length
-    (0..10).each do |power|
-      assert((10 ** power).length == (power + 1))
-    end
-  end
-end
-

data/test/core/kernel/test_deepcopy.rb

@@ -1,27 +0,0 @@
-require 'facets/kernel/deep_copy.rb'
-require 'test/unit'
-
-class TestKernelDeepCopy < Test::Unit::TestCase
-
-  # fixtures for copy / deep_copy
-  class A
-    attr_reader :a
-    def initialize
-      @a = 1
-    end
-  end
-
-  class B
-    attr_reader :b
-    def initialize
-      @b = A.new
-    end
-  end
-
-  def test_deep_copy
-    o = B.new
-    oc = o.deep_copy
-    assert_equal( 1, o.b.a  )
-  end
-
-end

data/test/core/kernel/test_resc.rb

@@ -1,12 +0,0 @@
-require 'facets/kernel/resc'
-require 'test/unit'
-
-class TestKernelResc < Test::Unit::TestCase
-
-  def test_resc
-    assert_equal( Regexp.escape("'jfiw0[]4"), resc("'jfiw0[]4") )
-    assert_equal( Regexp.escape("/////"), resc("/////") )
-  end
-
-end
-

data/test/core/module/test_conflict.rb

@@ -1,24 +0,0 @@
-require 'facets/module/conflict'
-require 'test/unit'
-
-class Test_Module_Conflict < Test::Unit::TestCase
-
-  class X
-    def q; "qx"; end
-  end
-
-  class Y
-    def q; "qy"; end
-  end
-
-  if RUBY_VERSION < '1.9'
-    def test_conflict?
-      assert_equal( ["q"], X.conflict?(Y) )
-    end
-  else
-    def test_conflict?
-      assert_equal( [:q], X.conflict?(Y) )
-    end
-  end
-end
-

data/test/core/module/test_modspace.rb

@@ -1,13 +0,0 @@
-require 'facets/module/modspace.rb'
-require 'test/unit'
-
-class TestModuleModSpace < Test::Unit::TestCase
-
-  def test_modspace
-    assert_equal( Test::Unit, Test::Unit::TestCase.modspace )
-    assert_equal( ::Test::Unit, ::Test::Unit::TestCase.modspace )
-    assert_equal( Object, ::Test.modspace )
-  end
-
-end
-

data/test/core/module/test_nesting.rb

@@ -1,21 +0,0 @@
-require 'facets/module/nesting.rb'
-require 'test/unit'
-
-class TestModuleNesting < Test::Unit::TestCase
-
-  module M
-    module N
-      class C
-        def n
-          self.class.nesting
-        end
-      end
-    end
-  end
-
-  def test_nesting
-    assert_equal( [TestModuleNesting, M, M::N, M::N::C], M::N::C.new.n )
-  end
-
-end
-

data/test/core/module/test_prepend.rb

@@ -1,29 +0,0 @@
-require 'facets/module/prepend'
-require 'test/unit'
-
-class Test_Module_Prepend < Test::Unit::TestCase
-
-  module M
-    def q; "qm"; end
-  end
-
-  module N
-    prepend M
-    def q; "qn"; end
-  end
-
-  class X
-    include N
-  end
-
-  def test_prepend_module_method
-    assert_equal( "qm", N.q )
-  end
-
-  # Wish this worked. 
-  #def test_prepend_instance_method
-  #  assert_equal( "qm", X.new.q )
-  #end
-
-end
-

data/test/core/string/test_chars.rb

@@ -1,12 +0,0 @@
-require 'facets/string/chars'
-require 'test/unit'
-
-class TC_String_Chars < Test::Unit::TestCase
-
-  def test_chars
-    assert_equal( ["a","b","c"], "abc".chars )
-    assert_equal( ["a","b","\n","c"], "ab\nc".chars )
-  end
-
-end
-

data/test/core/string/test_outdent.rb

@@ -1,65 +0,0 @@
-require 'facets/string/outdent'
-require 'test/unit'
-
-class TC_String_Outdent < Test::Unit::TestCase
-
-  def setup
-    @poem1 = <<-EOF
-    I must go down to the seas again
-      The lonely sea and the sky
-    And all I want is a tall ship
-      And a star to steer her by
-    EOF
-
-    @poem2 = <<-EOF
-       "Eek!"
-    She cried
-      As the mouse quietly scurried
-  by.
-    EOF
-  end  # def setup
-
-  def test_outdent_0
-    assert_equal("    xyz", "   xyz".outdent(-1))
-    assert_equal("   xyz", "   xyz".outdent(0))
-    assert_equal("  xyz", "   xyz".outdent(1))
-    assert_equal(" xyz", "   xyz".outdent(2))
-    assert_equal("xyz", "   xyz".outdent(3))
-    assert_equal("xyz", "   xyz".outdent(4))
-  end
-
-  def test_outdent_1
-    expected = <<-EOF
-   I must go down to the seas again
-     The lonely sea and the sky
-   And all I want is a tall ship
-     And a star to steer her by
-    EOF
-    actual = @poem1.outdent(1)
-    assert_equal(expected, actual)
-  end
-
-  def test_outdent_2
-    expected = <<-EOF
-I must go down to the seas again
-  The lonely sea and the sky
-And all I want is a tall ship
-  And a star to steer her by
-    EOF
-    actual = @poem1.outdent(4)
-    assert_equal(expected, actual)
-  end
-
-  def test_outdent_3
-    expected = <<-EOF
-"Eek!"
-She cried
-As the mouse quietly scurried
-by.
-    EOF
-    actual = @poem2.outdent(100)
-    assert_equal(expected, actual)
-  end
-
-end
-

data/test/core/test_blank.rb

@@ -1,12 +0,0 @@
-require 'facets/blank.rb'
-require 'test/unit'
-
-class TestStringBlank < Test::Unit::TestCase
-
-  def test_blank?
-    assert( ! "xyz".blank? )
-    assert( "     ".blank? )
-  end
-
-end
-

data/test/core/test_boolean.rb

@@ -1,89 +0,0 @@
-# Test for facets/boolean.rb
-
-require 'facets/boolean.rb'
-require 'test/unit'
-
-
-class TestStringBoolean < Test::Unit::TestCase
-
-  def test_to_b
-    assert( 'true'.to_b )
-    assert( 'True'.to_b )
-    assert( 'yes'.to_b )
-    assert( 'YES'.to_b )
-    assert( 'on'.to_b )
-    assert( 'ON'.to_b )
-    assert( 't'.to_b )
-    assert( '1'.to_b )
-    assert( 'y'.to_b )
-    assert( 'Y'.to_b )
-    assert( '=='.to_b )
-    assert( ! 'nil'.to_b )
-    assert( ! 'false'.to_b )
-    assert( ! 'blahblahtrueblah'.to_b )
-    assert_equal( nil, 'nil'.to_b )
-    assert_equal( nil, 'null'.to_b )
-  end
-
-end
-
-
-class TestArrayBoolean < Test::Unit::TestCase
-
-  def test_to_b
-    a = []
-    assert_equal( false, a.to_b )
-  end
-
-end
-
-
-class TestNumericBoolean < Test::Unit::TestCase
-
-  def test_to_b
-    assert_equal( false, 0.to_b )
-    assert_equal( true, 1.to_b )
-  end
-
-end
-
-
-class TestKernelBoolean < Test::Unit::TestCase
-
-  def test_to_b
-    assert_equal( true, true.to_b )
-    assert_equal( false, false.to_b )
-    assert_equal( false, nil.to_b )
-  end
-
-  def test_false?
-    assert( false.false? )
-    assert( (1 == 2).false? )
-    assert( ! (1 == 1).false? )
-  end
-
-  def test_true?
-    assert( true.true? )
-    assert( (1 == 1).true? )
-    assert( ! (1 == 2).true? )
-  end
-
-  def test_bool?
-    assert_equal( true, true.bool? )
-    assert_equal( true, false.bool? )
-    assert_equal( false, nil.bool? )
-    assert_equal( false, 0.bool? )
-  end
-
-end
-
-
-class TestBoolean < Test::Unit::TestCase
-
-  def test_to_bool
-    assert_equal( true, true.to_bool )
-    assert_equal( false, false.to_bool )
-    assert_equal( false, nil.to_bool )
-  end
-
-end

data/test/core/test_functor.rb

@@ -1,26 +0,0 @@
-# Test lib/facets/functor.rb
-
-require 'facets/functor.rb'
-require 'test/unit'
-
-class TC_Functor < Test::Unit::TestCase
-
-  def test_function
-    f = Functor.new { |op, x| x.send(op, x) }
-    assert_equal( 2, f + 1 ) #=> 2
-    assert_equal( 4, f + 2 ) #=> 4
-    assert_equal( 6, f + 3 ) #=> 6
-    assert_equal( 1, f * 1 ) #=> 1
-    assert_equal( 4, f * 2 ) #=> 4
-    assert_equal( 9, f * 3 ) #=> 9
-  end
-
-  def test_decoration
-    a = 'A'
-    f = Functor.new{ |op, x| x.send(op, a + x) }
-    assert_equal( 'BAB', f + 'B' )
-    assert_equal( 'CAC', f + 'C' )
-    assert_equal( 'DAD', f + 'D' )
-  end
-
-end

data/test/core/test_metaid.rb

@@ -1,39 +0,0 @@
-require 'facets/metaid.rb'
-require 'test/unit'
-
-class TestMetaid < Test::Unit::TestCase
-
-  def test_metaclass
-    o = Object.new
-    assert_equal( (class << o; self; end), o.metaclass )
-  end
-
-  def test_meta_class
-    o = Object.new
-    assert_equal( (class << o; self; end), o.meta_class )
-  end
-
-  #def test_singleton
-  #  o = Object.new
-  #  assert_equal( (class << o; self; end), o.singleton )
-  #end
-
-  #def test_singleton_eval
-  #  assert_nothing_raised do
-  #    o.singleton_class_eval{ @@a = "test" }
-  #  end
-  #end
-
-  #def test_singleton_method
-  #  assert_nothing_raised do
-  #    o.define_singleton_method(:testing){ |x| x + 1 }
-  #  end
-  #  assert_equal(2, o.testing(1) )
-  #end
-
-  #def test_singleton_class
-  #  o = Object.new
-  #  assert_equal( (class << o; self; end), o.singleton_class )
-  #end
-
-end

data/test/core/test_to_hash.rb

@@ -1,244 +0,0 @@
-require 'facets/to_hash.rb'
-require 'test/unit'
-
-
-class TestArrayConversion < Test::Unit::TestCase
-
-  def test_to_h
-    a = [1,2,3,4]
-    x = {1=>2,3=>4}
-    assert_equal(x, a.to_h)
-  end
-
-  #def test_to_h_odd_number_of_entries
-  #  assert_raise(ArgumentError) { [[1,:a],:b].to_h }
-  #end
-
-  def test_to_h_auto
-    a0 = [ [:a,1], [:b,2] ]
-    x0 = { :a=>1, :b=>2 }
-
-    a1 = [ [:a,1,2], [:b,2], [:c], [:d] ]
-    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-
-    a2 = [ [:a,1,2], 2, :b, [:c,3], 9 ]
-    x2 = { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
-
-    assert_equal(x0, a0.to_h_auto)
-    assert_equal(x1, a1.to_h_auto)
-    assert_equal(x2, a2.to_h_auto)  
-  end
-
-  def test_to_h_flat
-    a = [[1,2],3,4,5]
-    x = {1=>2,3=>4,5=>nil}
-    assert_equal(x, a.to_h_flat)
-  end
-
-  def test_to_h_splat
-    a = [1,2,3,4,[5,6]]
-    x = { 1=>2, 3=>4, [5,6]=>nil }
-    assert_equal(x, a.to_h_splat)
-  end
-
-  def test_to_h_assoc
-    a0 = [[:a,1],[:b,2],[:c],:d,[:a,5]]
-    x0 = {:a=>[5],:b=>[2],:c=>[],:d=>[]}
-
-    a1 = [ [:a,1,2], [:b,2], [:c], :d ]
-    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-
-    a2 = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
-    x2 = { :x=>[4] }
-
-    assert_equal(x0, a0.to_h_assoc)
-    assert_equal(x1, a1.to_h_assoc)
-    assert_equal(x2, a2.to_h_assoc)
-  end
-
-  def test_to_h_multi
-    a0 = [[:a,1],[:b,2],[:c],:d,[:a,5]]
-    x0 = {:a=>[1,5],:b=>[2],:c=>[],:d=>[]}
-
-    a1 = [ [:a,1,2], [:b,2], [:c], :d ]
-    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-
-    a2 = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
-    x2 = { :a=>[1,2,3,4] }
-
-    assert_equal(x0, a0.to_h_multi)
-    assert_equal(x1, a1.to_h_multi)
-    assert_equal(x2, a2.to_h_multi)
-  end
-
-  #def test_to_h_assoc_arrayed
-  #  a = [[:a,1,2],[:b,3,4],[:c,5,6]]
-  #  x = { :a=>[1,2], :b=>[3,4], :c=>[5,6] }
-  #  assert_equal(x, a.to_h(true))
-  #end
-
-  #def test_to_hash
-  #  a = [:a,:b,:c]
-  #  assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_hash )
-  #end
-
-  def test_to_h_assoc_dispatched
-    a = [:a, 1, [:b, 2, :c]]
-    assert_equal(a.to_h_assoc, a.to_h(:assoc))
-  end
-  
-  def test_to_h_flat_dispatched
-    a = [:a, 1, [:b, 2, :c]]
-    assert_equal(a.to_h_flat, a.to_h(:flat))
-  end
-  
-  def test_to_h_multi_dispatched
-    a = [:a, 1, [:b, 2, :c]]
-    assert_equal(a.to_h_multi, a.to_h(:multi))
-  end
-  
-  def test_to_h_splat_dispatched
-    a = [:a, 1, [:b, 2, :c]]
-    assert_equal(a.to_h_splat, a.to_h(:splat))
-  end
-
-end
-
-
-class TestEnumerableConversion < Test::Unit::TestCase
-
-  def test_to_h
-    a = [[1,:a],[2,:b],[3,:c]]
-    x = {1=>:a, 2=>:b, 3=>:c}
-    assert_equal(x, a.to_h )
-  end
-
-  def test_to_h_flat
-    a = [1,2,[3,4]]
-    x = {1=>2, 3=>4}
-    assert_equal(x, a.to_h_flat)
-  end
-  
-  def test_to_h_multi
-    a = [[:a,1,2],[:b,3,4],[:c,5,6]]
-    x = {:a=>[1,2], :b=>[3,4], :c=>[5,6]}
-    assert_equal(x, a.to_h_multi)
-  end
-
-  #def test_to_h_arrayed_flat
-  #  a = [1,2,3]
-  #  x = {1=>[],2=>[],3=>[]}
-  #  assert_equal(x, a.to_h(true))
-  #end
-
-  #def test_to_hash
-  #  a = [:a,:b,:c]
-  #  assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_hash )
-  #end
-
-end
-
-
-class TestHashConversion < Test::Unit::TestCase
-
-  def test_to_h
-    a = { :a => 1, :b => 2, :c => 3 }
-    assert_equal( a, a.to_h )
-  end
-
-end
-
-
-class TestNilClassConversion < Test::Unit::TestCase
-
-  def test_to_h
-    assert_equal( {}, nil.to_h )
-  end
-
-end
-
-
-class TestEnumeratorConversion < Test::Unit::TestCase
-
-  def test_to_h
-    e0 = [1,2,3,4].to_enum
-    x0 = {1=>2,3=>4}
-    e1 = [[1,:a],[2,:b],[3,:c]].to_enum
-    x1 = { 1=>:a, 2=>:b, 3=>:c }
-    e2 = [:a,1,:b].to_enum
-    x2 = {:a=>1,:b=>nil}
-    assert_equal(x0, e0.to_h)
-    assert_equal(x1, e1.to_h)
-    assert_equal(x2, e2.to_h)
-  end
-  
-  def test_to_h_auto
-    e0 = [ [:a,1], [:b,2] ].to_enum
-    x0 = { :a=>1, :b=>2 }
-    e1 = [ [:a,1,2], [:b,2], [:c], [:d] ].to_enum
-    x1 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    e2 = [ [:a,1,2], 2, :b, [:c,3], 9 ].to_enum
-    x2 = { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
-    assert_equal(x0, e0.to_h_auto)
-    assert_equal(x1, e1.to_h_auto)
-    assert_equal(x2, e2.to_h_auto)  
-  end  
-
-  def test_to_h_flat
-    e1 = [[1,2],3,4,5].to_enum
-    x1 = {1=>2,3=>4,5=>nil}
-    e2 = [:a,1,[:b,2,:c]].to_enum
-    x2 = { :a=>1, :b=>2, :c=>nil }        
-    e3 = [[:a,1],[:b,2]].to_enum
-    x3 = { :a=>1, :b=>2 }    
-    assert_equal(x1, e1.to_h_flat)
-    assert_equal(x1, e1.to_h(:flat))
-    assert_equal(x2, e2.to_h_flat)
-    assert_equal(x2, e2.to_h(:flat))
-    assert_equal(x3, e3.to_h_flat)
-    assert_equal(x3, e3.to_h(:flat))
-  end
-
-  def test_to_h_splat
-    e1 = [1,2,3,4,[5,6]].to_enum
-    x1 = { 1=>2, 3=>4, [5,6]=>nil }
-    e2 = [:a,1,:b,2,:c].to_enum
-    x2 = { :a=>1, :b=>2, :c=>nil }
-    assert_equal(x1, e1.to_h_splat)
-    assert_equal(x1, e1.to_h(:splat))
-    assert_equal(x2, e2.to_h_splat)
-    assert_equal(x2, e2.to_h(:splat))
-  end
-
-  def test_to_h_assoc
-    e1 = [[:a,1],[:b,2],[:c],:d,[:a,5]].to_enum
-    x1 = {:a=>[5],:b=>[2],:c=>[],:d=>[]}
-    e2 = [ [:a,1,2], [:b,2], [:c], :d ].to_enum
-    x2 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    e3 = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ].to_enum
-    x3 = { :x=>[4] }
-    assert_equal(x1, e1.to_h_assoc)
-    assert_equal(x1, e1.to_h(:assoc))
-    assert_equal(x2, e2.to_h_assoc)
-    assert_equal(x2, e2.to_h(:assoc))
-    assert_equal(x3, e3.to_h_assoc)
-    assert_equal(x3, e3.to_h(:assoc))
-  end
-
-  def test_to_h_multi
-    e1 = [[:a,1],[:b,2],[:c],:d,[:a,5]].to_enum
-    x1 = {:a=>[1,5],:b=>[2],:c=>[],:d=>[]}
-    e2 = [ [:a,1,2], [:b,2], [:c], :d ]
-    x2 = { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-    e3 = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
-    x3 = { :a=>[1,2,3,4] }
-    assert_equal(x1, e1.to_h_multi)
-    assert_equal(x1, e1.to_h(:multi))
-    assert_equal(x2, e2.to_h_multi)
-    assert_equal(x2, e2.to_h(:multi))
-    assert_equal(x3, e3.to_h_multi)
-    assert_equal(x3, e3.to_h(:multi))
-  end
- 
-end
-