facets 2.4.5 → 2.5.0

data/test/core/string/test_tabto.rb

@@ -0,0 +1,13 @@
+require 'facets/string/tabto'
+require 'test/unit'
+
+class TC_String_Tabto < Test::Unit::TestCase
+
+  def test_tabto
+    a = "xyz".tabto(4)
+    assert_equal( '    ', a[0..3] )
+    # Need to expand on this
+  end
+
+end
+

data/test/{more → core}/test_metaid.rb

@@ -13,10 +13,10 @@ class TestMetaid < Test::Unit::TestCase
     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
+  #  o = Object.new
+  #  assert_equal( (class << o; self; end), o.singleton )
+  #end
 
   #def test_singleton_eval
   #  assert_nothing_raised do
@@ -31,9 +31,9 @@ class TestMetaid < Test::Unit::TestCase
   #  assert_equal(2, o.testing(1) )
   #end
 
-  def test_singleton_class
-    o = Object.new
-    assert_equal( (class << o; self; end), o.singleton_class )
-  end
+  #def test_singleton_class
+  #  o = Object.new
+  #  assert_equal( (class << o; self; end), o.singleton_class )
+  #end
 
 end

data/test/core/time/test_hence.rb

@@ -4,10 +4,124 @@ require 'time'
 
 class TC_Time_Hence < Test::Unit::TestCase
 
-  def test_hence
-    t1 = Time.parse('8/20/2005 15:37')
-    t2 = t1.hence(5, :months)
-    assert_equal( 1, t2.month )
+  def test_change_years
+    assert_equal Time.utc(2007,11, 1, 18,30,57),
+                 Time.utc(2008,11, 1, 18,30,57).ago(1, :years)
+
+    assert_equal Time.utc(2008,11, 1, 18,30,57),
+                 Time.utc(2007,11, 1, 18,30,57).hence(1, :years)
+  end
+
+  def test_change_weeks
+    assert_equal Time.utc(2008,11,24, 18,30,57),
+                 Time.utc(2008,12, 1, 18,30,57).ago(1, :weeks)
+
+    assert_equal Time.utc(2008,12, 1, 18,30,57),
+                 Time.utc(2008,11,24, 18,30,57).hence(1, :weeks)
+  end
+
+  def test_change_days
+    assert_equal Time.utc(2008,11,30, 18,30,57),
+                 Time.utc(2008,12, 1, 18,30,57).ago(1, :days)
+
+    assert_equal Time.utc(2008,12, 1, 18,30,57),
+                 Time.utc(2008,11,30, 18,30,57).hence(1, :days)
+  end
+
+  def test_change_hours
+    assert_equal Time.utc(2008,11,30, 23,30,57),
+                 Time.utc(2008,12, 1,  0,30,57).ago(1, :hours)
+
+    assert_equal Time.utc(2008,12, 1,  0,30,57),
+                 Time.utc(2008,11,30, 23,30,57).hence(1, :hours)
+  end
+
+  def test_change_minutes
+    assert_equal Time.utc(2008,11,30, 23,58,57),
+                 Time.utc(2008,12, 1,  0, 0,57).ago(2, :minutes)
+
+    assert_equal Time.utc(2008,12, 1,  0, 0,57),
+                 Time.utc(2008,11,30, 23,58,57).hence(2, :minutes)
+  end
+
+  def test_change_seconds
+    assert_equal Time.utc(2008,11,30, 23,59,57),
+                 Time.utc(2008,12, 1,  0, 0, 1).ago(4, :seconds)
+
+    assert_equal Time.utc(2008,12, 1,  0, 0, 1),
+                 Time.utc(2008,11,30, 23,59,57).hence(4, :seconds)
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  # Months are the tricky one, so they get their own little section
+
+  def test_change_month_no_year_wrap
+    assert_equal Time.utc(2008,11, 1),
+                 Time.utc(2008,12, 1).ago(1, :months)
+
+    assert_equal Time.utc(2008,12, 1),
+                 Time.utc(2008,11, 1).hence(1, :months)
+  end
+
+  def test_change_month_with_year_wrap_due_to_month
+    assert_equal Time.utc(2007,12, 1),
+                 Time.utc(2008, 1, 1).ago(1, :months)
+
+    assert_equal Time.utc(2008, 1, 1),
+                 Time.utc(2007,12, 1).hence(1, :months)
+  end
+
+  def test_change_month_with_12_or_more_converts_extra_months_into_a_year_adjustment
+    (
+    assert_equal Time.utc(2007, 1, 1),
+                 Time.utc(2008, 1, 1).ago(12, :months)
+
+    assert_equal Time.utc(2008, 1, 1),
+                 Time.utc(2007, 1, 1).hence(12, :months)
+    )
+    (
+    assert_equal Time.utc(2006,11, 1),
+                 Time.utc(2008,12, 1).ago(25, :months)
+
+    assert_equal Time.utc(2008,12, 1),
+                 Time.utc(2006,11, 1).hence(25, :months)
+    )
+  end
+
+  def test_change_month_with_12_or_more_AND_year_wrap_due_to_month
+    (
+    # 13 months = 1 year + 1 month AND month changing from 12 to 1 when going backward means go back 1 extra  year
+    assert_equal Time.utc(2006,12, 1),
+                 Time.utc(2008, 1, 1).ago(13, :months)
+
+    assert_equal Time.utc(2008, 1, 1),
+                 Time.utc(2006,12, 1).hence(13, :months)
+
+    )
+    (
+    # Smaller units should remain unchanged.
+    assert_equal Time.utc(2005, 8,20, 15,37,59),
+                 Time.utc(2006, 1,20, 15,37,59).ago(5, :months)
+
+    assert_equal Time.utc(2006, 1,20, 15,37,59),
+                 Time.utc(2005, 8,20, 15,37,59).hence(5, :months)
+    )
+  end
+
+  def test_passing_a_negative_number_to_ago_should_be_same_as_a_positive_number_to_hence
+    assert_equal Time.utc(2008, 1, 1),
+                 Time.utc(2006,12, 1).ago(-13, :months)
+
+    assert_equal Time.utc(2006, 1,20),
+                 Time.utc(2005, 8,20).ago(-5, :months)
+  end
+
+  def test_passing_a_negative_number_to_hence_should_be_same_as_a_positive_number_to_ago
+    assert_equal Time.utc(2006,12, 1),
+                 Time.utc(2008, 1, 1).hence(-13, :months)
+
+    assert_equal Time.utc(2005, 8,20),
+                 Time.utc(2006, 1,20).hence(-5, :months)
   end
 
 end

data/test/core/unboundmethod/test_name.rb

@@ -1,4 +1,4 @@
-require 'facets/unboundmethod/arguments'
+require 'facets/unboundmethod/name'
 
 class Test_UnboundMethod < Test::Unit::TestCase
 

data/test/more/{test_arguments.rb → test_argvector.rb}

@@ -1,15 +1,11 @@
-# Test for facets/arguments.rb.
-
 require 'test/unit'
-require 'facets/arguments.rb'
-
-class TestArguments < Test::Unit::TestCase
+require 'facets/argvector.rb'
 
-  include CLI
+class TestArgvector < Test::Unit::TestCase
 
   def test_parameters
     line = "-x baz --foo=8 bar"
-    cargs = Arguments.new(line)
+    cargs = Argvector.new(line)
     args, keys = cargs.parameters
     assert_equal(['baz','bar'], args)
     assert_equal({'foo'=>'8','x'=>true}, keys)
@@ -17,7 +13,7 @@ class TestArguments < Test::Unit::TestCase
 
   def test_parameters_with_arity
     line = "-g a -x b -x c"
-    cargs = Arguments.new(line, :g=>1, :x=>1)
+    cargs = Argvector.new(line, :g=>1, :x=>1)
     args, keys = cargs.parameters
     assert_equal({'g'=>'a','x'=>['b','c']}, keys)
     assert_equal([], args)
@@ -25,14 +21,14 @@ class TestArguments < Test::Unit::TestCase
 
   def test_flags
     line = "-x baz --foo=8 bar"
-    cargs = Arguments.new(line)
+    cargs = Argvector.new(line)
     flags = cargs.flags
     assert_equal(['x'], flags)
   end
 
   def test_repeat
     line = "-x baz --foo=1 --foo=2 bar"
-    cargs = Arguments.new(line)
+    cargs = Argvector.new(line)
     args, keys = cargs.parameters
     assert_equal(['baz','bar'], args)
     assert_equal({'x'=>true,'foo'=>['1','2']}, keys)
@@ -40,14 +36,14 @@ class TestArguments < Test::Unit::TestCase
 
   def test_preoptions
     line = "-x --foo=7 baz -y bar"
-    cargs = Arguments.new(line)
+    cargs = Argvector.new(line)
     flags = cargs.preoptions
     assert_equal({'x'=>true,'foo'=>'7'}, flags)
   end
 
   def test_with_arity
     line = "-q baz --aq 5 bar"
-    cargs = Arguments.new(line,'aq'=>1)
+    cargs = Argvector.new(line,'aq'=>1)
     words, flags = cargs.parameters
     assert_equal(['baz','bar'],words)
     assert_equal({'q'=>true,'aq'=>'5'},flags)

data/test/more/test_filter.rb

@@ -0,0 +1,87 @@
+require 'facets/filter'
+require 'test/unit'
+
+class TC_Enumerator_Filter < Test::Unit::TestCase
+
+  SOURCE = (1..1/0.0)   # infinite Enumerable object
+
+  def test_enumerator_with_block
+    # This example taken from ri19 Enumerator.new
+    fib = Enumerator.new { |y|
+      a = b = 1
+      loop {
+        y << a
+        a, b = b, a + b
+      }
+    }
+    assert_equal [1, 1, 2, 3, 5, 8, 13, 21, 34, 55], fib.take(10)
+  end
+  
+  def test_filter_without_block
+    a = SOURCE.filter
+    assert_equal Enumerator::Filter, a.class
+    assert_equal [1,2,3,4,5], a.take(5).to_a
+  end
+
+  def test_filter_with_block
+    a = SOURCE.filter { |out,i| out << i*2 }
+    assert_equal Enumerator::Filter, a.class
+    assert_equal [2,4,6,8,10], a.take(5).to_a
+  end
+
+  def test_each
+    res = []
+    (1..5).filter.each { |i| res << i }
+    assert_equal [1,2,3,4,5], res
+  end
+
+  def test_return
+    res = (1..5).filter.inject({}) { |h,v| h[v] = v*2; h }
+    assert_equal({1=>2,2=>4,3=>6,4=>8,5=>10}, res)
+    res = (1..5).filter.inject({}) { |h,v| h[v] = v*2; break h if v>=3; h }
+    assert_equal({1=>2,2=>4,3=>6}, res)
+  end
+
+  def test_other_enumerable
+    a = SOURCE.filter
+    assert_equal 5, a.take(5).max
+    assert_equal 2, a.map { |i| i*2 }.take(5).min
+    assert_equal [5,4,3,2,1], a.take(5).sort_by { |x| -x }
+  end
+
+  def test_filter_filter
+    a = SOURCE.filter.filter { |out,i| out << i*2 }
+    assert_equal [2,4,6,8,10], a.take(5).to_a
+  end
+
+  def test_filter_chain
+    a = SOURCE.filter { |out,i| out.yield(i) if i % 2 == 0 }.
+               filter { |out,i| out.yield(i + 100) }
+    assert_equal [102,104,106,108,110], a.take(5).to_a
+  end
+
+  def test_select_map
+    a = SOURCE.filter.select { |i| i % 2 == 0 }.map { |i| i + 100 }
+    assert_equal [102,104,106,108,110], a.take(5).to_a
+  end
+
+  def test_find_all_collect
+    a = SOURCE.filter.find_all { |i| i % 2 == 0 }.collect { |i| i + 100 }
+    assert_equal [102,104,106,108,110], a.take(5).to_a
+  end
+
+  def test_reject
+    a = SOURCE.filter.reject { |i| i % 3 == 0 }
+    assert_equal [1,2,4,5,7], a.take(5).to_a
+  end
+
+  def test_skip_take
+    a = SOURCE.filter.skip(20).take(5)
+    assert_equal [21,22,23,24,25], a.to_a
+  end
+
+  #def test_each_cons
+  #  a = SOURCE.filter
+  #  assert_equal [[1,2,3],[2,3,4],[3,4,5],[4,5,6]], a.each_cons(3).take(4)
+  #end
+end

data/test/more/test_memoize.rb

@@ -17,19 +17,21 @@ class TC_Memoize < Test::Unit::TestCase
 
 
   def setup
-    @t = T.new(2)
+    @t1 = T.new(1)
+    @t2 = T.new(2)
+    @t3 = T.new(3)
   end
 
-  def test_memoize_01
-    assert_equal( @t.a, @t.a )
+  def test_memoize_gives_correct_value
+    assert_equal( @t1.a, "6" )
+    assert_equal( @t2.a, "5" )
+    assert_equal( @t3.a, "4" )
   end
 
-  def test_memoize_02
-    assert_equal( @t.a.__id__, @t.a.__id__ )
-  end
-
-  def test_memoize_03
-    assert_equal( @t.a.__id__, @t.a.__id__ )
+  def test_memoize_returns_identical_objects
+    assert_equal( @t1.a.__id__, @t1.a.__id__ )
+    assert_equal( @t2.a.__id__, @t2.a.__id__ )
+    assert_equal( @t3.a.__id__, @t3.a.__id__ )
   end
 
 end

data/test/more/test_sparsearray.rb

@@ -0,0 +1,279 @@
+# This is a mostly complete testcase for SparseArray.
+# SparseArray is tested by comparison to standard Array.
+
+require 'test/unit'
+require 'facets/sparse_array'
+
+class TC_SparseArray < Test::Unit::TestCase
+
+  def aha(a)
+    return a, SparseArray[*a]
+  end
+
+  def test_conversions
+    a, ha = aha [1,3,'a',8,nil,[1]]
+    assert_equal(ha, ha.to_ary)  # these need to be opposite
+    assert_equal(a, ha.to_a)     #
+    assert_equal(a.to_s, ha.to_s)
+  end
+
+  def test_set_operations
+    a, ha = aha [1,3,5,8,9]
+    b, hb = aha [2,3,6,8,9]
+    assert_equal(a | b, (ha | hb).to_a)
+    assert_equal(a & b, (ha & hb).to_a)
+    assert_equal(a + b, (ha + hb).to_a)
+    assert_equal(a - b, (ha - hb).to_a)
+  end
+
+  def test_multiple
+    a, ha = aha [1,3]
+    assert_equal(a*3,(ha*3).to_a)
+  end
+
+  def test_assign
+    a, ha = aha [1,2,3,4]
+    a[1..2] = [8,9]
+    ha[1..2] = [8,9]
+    assert_equal(a, ha.to_a)
+  end
+  def test_assoc
+    a, ha = aha [[1,2],[3,4],[3,6]]
+    assert_equal(a.assoc(3), ha.assoc(3).to_a)
+  end
+  def test_at
+    a, ha = aha [4,5,6,6]
+    assert_equal(a.at(0), ha.at(0))
+    assert_equal(a.at(2), ha.at(2))
+    assert_equal(a.at(4), ha.at(4))
+    assert_equal(a.at(9), ha.at(9))
+    assert_equal(a.at(-1), ha.at(-1))
+    assert_equal(a.at(-3), ha.at(-3))
+    assert_equal(a.at(-4), ha.at(-4))
+    assert_equal(a.at(-5), ha.at(-5))
+  end
+  def test_collect
+    a, ha = aha [4,5,6,6]
+    assert_equal(a.collect{|e|e}, ha.collect{|e|e}.to_a)
+    assert_equal(a.collect!{|e|e}, ha.collect!{|e|e}.to_a)
+    assert_equal(a,ha.to_a)
+  end
+  def test_compact
+    a, ha = aha [4,nil,5,nil,6]
+    assert_equal(a.compact, ha.compact.to_a)
+  end
+  def test_concat
+    a, ha = aha [1,3,5,8,9]
+    b, hb = aha [2,3,6,8,9]
+    assert_equal(a.concat(b),ha.concat(hb).to_a)
+  end
+  def test_count
+    ha = SparseArray[9,3,9,5,nil,nil,9,3]
+    assert_equal(2,ha.count)
+    assert_equal(2,ha.count(3))
+    assert_equal(3,ha.count{|e|e==9})
+  end
+  def test_delete
+    a, ha = aha [1,3,5,8,9,'a','b','c','c','d']
+    # test delete
+    assert_equal(a.delete(1),ha.delete(1))
+    assert_equal(a,ha.to_a)
+    assert_equal(a.delete('a'),ha.delete('a'))
+    assert_equal(a,ha.to_a)
+    # test delete_at
+    assert_equal(a.delete_at(0),ha.delete_at(0))
+    assert_equal(a,ha.to_a)
+    # test delete_if
+    assert_equal(a.delete_if{|v|v=='c'},ha.delete_if{|v|v=='c'}.to_a)
+    assert_equal(a,ha.to_a)
+  end
+  def test_each
+    a, ha = aha [4,'a',nil,'b']
+    # test each
+    ca, cha = '', ''
+    a.each{|e| ca += e.to_s}
+    ha.each{|e| cha += e.to_s}
+    assert_equal(ca,cha)
+    assert_equal(a,ha.to_a)
+    # test each_index
+    ca, cha = '', ''
+    a.each_index{|i| ca += i.to_s}
+    ha.each_index{|i| cha += i.to_s}
+    assert_equal(ca,cha)
+    assert_equal(a,ha.to_a)
+  end
+  def test_eql?
+    a, ha = aha [4,'a',nil,'b']
+    b, hb = aha [4,'a',nil,'b']
+    assert_equal(a,b)
+    assert_equal(ha,hb)
+    assert_equal(a.eql?(b),ha.eql?(hb))
+    assert_equal(b.eql?(a),hb.eql?(ha))
+    assert(ha.eql?(hb))
+    assert(hb.eql?(ha))
+  end
+  def test_empty?
+    a, ha = aha []
+    assert_equal(a.empty?,ha.empty?)
+    a, ha = aha [1,2,3]
+    assert_equal(a.empty?,ha.empty?)
+  end
+  def test_fill
+    a, ha = aha ['a','b','c','d']
+    assert_equal(a.fill('x'),ha.fill('x').to_a)
+    assert_equal(a,ha.to_a)
+    assert_equal(a.fill('y',2,2),ha.fill('y',2,2).to_a)
+    assert_equal(a,ha.to_a)
+    assert_equal(a.fill('z',0..1),ha.fill('z',0..1).to_a)
+    assert_equal(a,ha.to_a)
+  end
+  def test_first
+    a, ha = aha [2,3,4]
+    assert_equal(a.first,ha.first)
+  end
+  def test_flatten
+    a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
+    assert_equal(a.flatten,ha.flatten.to_a)
+    a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
+    assert_equal(a.flatten!,ha.flatten!.to_a)
+    assert_equal(a,ha.to_a)
+    a, ha = aha [2,3,'a',nil,5]
+    assert_equal(a.flatten!,ha.flatten!)
+  end
+  def test_include?
+    a, ha = aha ['a','b','c','d']
+    assert_equal(a.include?('b'),ha.include?('b'))
+    assert_equal(a.include?('x'),ha.include?('x'))
+  end
+  def test_index
+    a, ha = aha ['a','b','b','c','d']
+    assert_equal(a.index('b'),ha.index('b'))
+    assert_equal(a.index('x'),ha.index('x'))
+  end
+  def test_join
+    a, ha = aha [2,3,4]
+    assert_equal(a.join,ha.join)
+    assert_equal(a.join(','),ha.join(','))
+  end
+  def test_last
+    a, ha = aha [2,3,4]
+    assert_equal(a.last,ha.last)
+  end
+  def test_length
+    a, ha = aha [2,3,4]
+    assert_equal(a.length,ha.length)
+  end
+  def test_map!
+    a, ha = aha [4,5,6,6]
+    assert_equal(a.map!{|e|e}, ha.map!{|e|e}.to_a)
+    assert_equal(a,ha.to_a)
+  end
+  def test_nitems
+    a, ha = aha [4,5,nil,6,nil]
+    assert_equal(a.nitems, ha.nitems)
+  end
+  def test_pop
+    a, ha = aha [4,5,nil,6,nil]
+    assert_equal(a.pop, ha.pop)
+    assert_equal(a, ha.to_a)
+    assert_equal(a.pop, ha.pop)
+    assert_equal(a, ha.to_a)
+  end
+  def test_push
+    a, ha = aha [4,5,nil,6,nil]
+    args = [1,2,3]
+    assert_equal(a.push(*args), ha.push(*args).to_a)
+    assert_equal(a, ha.to_a)
+  end
+  def test_rassoc
+    a, ha = aha [[1,2],[1,3],[1,3]]
+    assert_equal(a.rassoc(3), ha.rassoc(3).to_a)
+  end
+  def test_reject!
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.reject!{|v|v=='c'},ha.reject!{|v|v=='c'}.to_a)
+    assert_equal(a,ha.to_a)
+    assert_equal(a.reject!{|v|v=='x'},ha.reject!{|v|v=='x'})
+    assert_equal(a,ha.to_a)
+  end
+  def test_reverse
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.reverse,ha.reverse.to_a)
+    assert_equal(a.reverse!,ha.reverse!.to_a)
+    assert_equal(a,ha.to_a)
+    a, ha = aha [1,2,3,'a','b','c']
+    assert_equal(a.reverse!,ha.reverse!.to_a)
+    assert_equal(a,ha.to_a)
+  end
+  def test_reverse_each
+    a, ha = aha [4,'a',nil,'b']
+    # test each
+    ca, cha = '', ''
+    a.reverse_each{|e| ca += e.to_s}
+    ha.reverse_each{|e| cha += e.to_s}
+    assert_equal(ca,cha)
+    assert_equal(a,ha.to_a)
+  end
+  def test_rindex
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.rindex('c'),ha.rindex('c'))
+    assert_equal(a.rindex('x'),ha.rindex('x'))
+  end
+  def test_shift
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.shift,ha.shift)
+    assert_equal(a,ha.to_a)
+  end
+
+  def test_slice
+    a, ha = aha [1,2,3,4]
+    # test []
+    assert_equal(a[1], ha[1])
+    assert_equal(a[1..2], ha[1..2].to_a)
+    assert_equal(a[1...2], ha[1...2].to_a)
+    assert_equal(a[1..7], ha[1..7].to_a)
+    assert_equal(a[1,2], ha[1,2].to_a)
+    # test slice
+    assert_equal(a.slice(1), ha.slice(1))
+    assert_equal(a.slice(1..2), ha.slice(1..2).to_a)
+    assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
+    assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
+    assert_equal(a.slice(1,2), ha.slice(1,2).to_a)
+    # test slice!
+    assert_equal(a.slice!(1..2), ha.slice!(1..2).to_a)
+    assert_equal(a, ha.to_a)
+  end
+
+  def test_sort
+    a, ha = aha [1,2,3,4]
+    # test sort
+    assert_equal(a.sort, ha.sort.to_a)
+    #assert_equal(a.sort{|x,y| y<=>x}, ha.sort{|x,y| y<=>x}.to_a)
+    # test sort!
+    assert_equal(a.sort!, ha.sort!.to_a)
+    assert_equal(a, ha.to_a)
+  end
+
+  def test_uniq
+    a, ha = aha [1,1,2,3,3,4,5,6,6]
+    assert_equal(a.uniq, ha.uniq.to_a)
+  end
+
+  def test_uniq!
+    a, ha = aha [1,1,2,3,3,4,5,6,6]
+    a.uniq!; ha.uniq!
+    assert_equal(a, ha.to_a)
+  end
+
+  def test_values_at
+    a, ha = aha ['a','b','c','d']
+    assert_equal(a.values_at(1,3),ha.values_at(1,3).to_a)
+  end
+
+  def test_unshift
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.unshift('x'),ha.unshift('x').to_a)
+    assert_equal(a,ha.to_a)
+  end
+end
+