facets 2.8.4 → 2.9.0.pre.1

data/test/core/enumerable/test_each_by.rb

@@ -1,55 +1,45 @@
-require 'facets/enumerable/each_by'
-require 'test/unit'
+covers 'facets/enumerable/each_by'
 
-class TC_Enumerable_EachBy < Test::Unit::TestCase
+testcase Enumerable do
 
-  def test_each_by_01
-    x = []
-    [1,2,3,4].each_by{ |a,b| x << [a,b] }
-    o = [[1,2],[3,4]]
-    assert_equal( o, x )
-  end
-
-  def test_each_by_02
-    x = []
-    [1,2,3,4,5].each_by{ |a,b,c| x << [a,b,c] }
-    o = [[1,2,3],[4,5,nil]]
-    assert_equal( o, x )
-  end
-
-  def test_each_by_03
-    x = []
-    [1,2,3,4].each_by(2){ |a,b| x << [a,b] }
-    o = [[1,2],[3,4]]
-    assert_equal( o, x )
+  unit :each_by => "infer groups of two" do
+    e = [[1,2], [3,4], [5,6]]
+    a = [1,2,3,4,5,6]
+    r = []
+    a.each_by{ |a,b| r << [a,b] }
+    r.assert == e
   end
 
-  def test_each_by_04
-    x = []
-    [1,2,3,4,5,6,7,8].each_by(4){ |*a| x << a }
-    o = [ [[1,2,3,4]],[[5,6,7,8]] ]
-    assert_equal( o, x )
+  unit :each_by => "infer groups of three" do
+    e = [[1,2,3],[4,5,nil]]
+    a = [1,2,3,4,5]
+    r = []
+    a.each_by{ |a,b,c| r << [a,b,c] }
+    r.assert == e
   end
 
-  def test_each_by_05
-    x = []
-    [1,2,3,4,5,6].each_by(3){ |*a| x << a }
-    o = [ [[1,2,3]],[[4,5,6]] ]
-    assert_equal( o, x )
+  unit :each_by => "specify groups of two" do
+    e = [[1,2],[3,4]]
+    a = [1,2,3,4]
+    r = []
+    a.each_by(2){ |a,b| r << [a,b] }
+    r.assert == e
   end
 
-  def test_each_by_06
+  unit :each_by => "specify groups of three with splat argument" do
+    e = [ [[1,2,3]], [[4,5,6]] ]
     a = [1,2,3,4,5,6]
     r = []
-    a.each_by(2){ |x,y| r << [x,y] }
-    assert_equal( [[1,2],[3,4],[5,6]], r )
+    a.each_by(3){ |*a| r << a }
+    r.assert == e
   end
 
-  def test_each_by_07
-    a = [1,2,3,4,5,6]
+  unit :each_by => "specify groups of four with splat argument" do
+    e = [ [[1,2,3,4]], [[5,6,7,8]] ]
+    a = [1,2,3,4,5,6,7,8]
     r = []
-    a.each_by(3){ |*e| r << e }
-    assert_equal( [ [[1,2,3]], [[4,5,6]] ], r )
+    a.each_by(4){ |*a| r << a }
+    r.assert == e
   end
 
 end

data/test/core/enumerable/test_each_with_object.rb

@@ -0,0 +1,14 @@
+covers 'facets/enumerable/each_with_object'
+
+tests Enumerable do
+
+  unit :each_with_object do
+    r = Hash.new(0)
+    a = [1,2,2,3]
+
+    a.each_with_object(r){ |c, h| h[c] += 1 }
+
+    r.assert == { 1=>1, 2=>2, 3=>1 }
+  end
+
+end

data/test/core/enumerable/test_every.rb

@@ -1,25 +1,24 @@
-require 'facets/enumerable/every'
-require 'test/unit'
+covers 'facets/enumerable/every'
 
-class TCEvery < Test::Unit::TestCase
+testcase Enumerable do
 
-  def test_every
+  unit :every do
     a = [1,2,3]
-    assert_equal( [4,5,6], a.every + 3 )
-    assert_equal( [0,1,2], a.every - 1 )
-    assert_equal( ['1','2','3'], a.every.to_s )
+    (a.every + 3 ).assert == [4,5,6]
+    (a.every - 1).assert == [0,1,2]
+    (a.every.to_s).assert == ['1','2','3']
   end
 
-  def test_every!
+  unit :every! do
     a = [1,2,3]
     a.every! + 3
-    assert_equal( [4,5,6], a )
+    a.assert == [4,5,6]
   end
 
-  def test_to_enum_every
+  unit :every => "on Enumerator" do
     e = [1,2,3].to_enum(:map)
-    w = e.every + 3
-    assert_equal( [4,5,6], w )
+    r = e.every + 3
+    r.assert == [4,5,6]
   end
 
 end

data/test/core/enumerable/test_ewise.rb

@@ -1,23 +1,22 @@
-require 'facets/enumerable/ewise'
-require 'test/unit'
+covers 'facets/enumerable/ewise'
 
-class TestElementWise < Test::Unit::TestCase
+testcase Enumerable do
 
-  #def test_elementwise
-  #  a = [1,2,3]
-  #  b = [4,5]
-  #  assert_equal( [4,5,6], a.elementwise + 3 )
-  #  assert_equal( [5,7], a.elementwise + b )
-  #  assert_equal( [[5,7],[3,4,5]], a.elementwise.+(b,2) )
-  #  assert_equal( [[5,7],[4,5,6]], a.elementwise.+(b,3) )
-  #end
+  unit :ewise do
+    a = [1,2,3]
+    (a.ewise + 3).assert == [4,5,6]
+    (a.ewise + [4,5]).assert == [5,7]
+    (a.ewise.+([4,5],2)).assert == [[5,7],[3,4,5]]
+    (a.ewise.+([4,5],3)).assert == [[5,7],[4,5,6]]
+  end
 
-  def test_ewise
+  unit :elementwise do
     a = [1,2,3]
-    assert_equal( [4,5,6], a.ewise + 3 )
-    assert_equal( [5,7], a.ewise + [4,5] )
-    assert_equal( [[5,7],[3,4,5]], a.ewise.+([4,5],2) )
-    assert_equal( [[5,7],[4,5,6]], a.ewise.+([4,5],3) )
+    (a.elementwise + 3).assert == [4,5,6]
+    (a.elementwise + [4,5]).assert == [5,7]
+    (a.elementwise.+([4,5],2)).assert == [[5,7],[3,4,5]]
+    (a.elementwise.+([4,5],3)).assert == [[5,7],[4,5,6]]
   end
 
 end
+

data/test/core/enumerable/test_exclude.rb

@@ -0,0 +1,11 @@
+covers 'facets/enumerable/exclude'
+
+tests Enumerable do
+
+  unit :exclude? do
+    a = [1,2,2,3]
+    a.refute.exclude?(2)
+    a.assert.exclude?(4)
+  end
+
+end

data/test/core/enumerable/test_expand.rb

@@ -0,0 +1,11 @@
+covers 'facets/enumerable/expand'
+
+tests Enumerable do
+
+  unit :expand do
+    a = [1,2,2,[1,2]]
+    r = a.expand
+    r == [1,2,2,1,2]
+  end
+
+end

data/test/core/enumerable/test_filter.rb

@@ -0,0 +1,15 @@
+covers 'facets/enumerable/filter'
+
+testcase Enumerable do
+
+  unit :filter do
+    x = (1..10000)
+    x = x.filter{ |out,i| out << i if i % 2 == 0 }   # like select
+    x = x.filter{ |out,i| out << i + 100 }           # like map
+    x = x.take(3)
+
+    x.assert == [102, 104, 106]
+  end
+
+end
+

data/test/core/enumerable/test_find_yield.rb

@@ -1,48 +1,55 @@
-require 'facets/enumerable/find_yield'
-require 'test/unit'
+covers 'facets/enumerable/find_yield'
 
-class TestEnumerable < Test::Unit::TestCase
+testcase Enumerable do
   
-  def test_find_yields_a_value
-    assert_equal true, [true].find_yield { |value| value }
+  unit :find_yield => "a value" do
+    r = [true].find_yield { |value| value }
+    r.assert == true
   end
 
-  def test_find_yield_detects_correct_value
-    assert_equal 1, [1].find_yield { |value| value }
+  unit :find_yield => "detects correct value" do
+    r = [1].find_yield { |value| value }
+    r.assert == 1
   end
 
-  def test_find_yield_returns_value_of_block
-    assert_equal 4, [1].find_yield { |v| v + 3 }
+  unit :find_yield => "returns value of block" do
+    r = [1].find_yield { |v| v + 3 }
+    r.assert == 4
   end
 
-  def test_find_yield_detects_first_truthy_value
-    assert_equal 1, [false, false, 1].find_yield { |value| value }
+  unit :find_yield => "detects first truthy value" do
+    r = [false, false, 1].find_yield { |value| value }
+    r.assert == 1
   end
 
-  def test_find_yield_returns_value_when_block_is_true
-    assert_equal true, [false].find_yield { |value| true }
+  unit :find_yield => "returns value when block is true" do
+    r = [false].find_yield { |value| true }
+    r.assert == true
   end
 
-  def test_find_yield_returns_early_when_block_is_true
-    val1 = lambda { :something }
-    val2 = lambda { raise "This shouldn't be called" }
-
-    assert_equal :something, [val1, val2].find_yield { |obj| obj.call }
+  unit :find_yield => "returns early when block is true" do
+    v1 = lambda { :something }
+    v2 = lambda { raise "This shouldn't be called" }
+    r = [v1, v2].find_yield { |obj| obj.call }
+    r.assert == :something
   end
 
-  def test_find_yield_returns_nil_when_block_returns_false_for_all_elements
-    assert_equal nil, [1,2,3,4].find_yield { |value| false }
+  unit :find_yield => "returns nil when block returns false for all elements" do
+    r = [1,2,3,4].find_yield { |value| false }
+    r.assert == nil
   end
 
-  def test_find_yield_returns_nil_when_no_elements_in_collection
-    assert_equal nil, [].find_yield { |v| }
+  unit :find_yield => "returns nil when no elements in collection" do
+    r = [].find_yield { |v| }
+    r.assert == nil
   end
 
-  def test_find_yield_can_have_return_value_specified_when_block_isnt_true
-    assert_equal :a_value, [1,2,3].find_yield(:a_value) { |value| false }
+  unit :find_yield => "can have return value specified when block isnt true" do
+    r = [1,2,3].find_yield(:a_value){ |value| false }
+    r.assert == :a_value
   end
 
-  def test_find_yield_documentation_correct
+  unit :find_yield => "documentation correct" do
     obj1, obj2 = Object.new, Object.new
 
     class << obj1
@@ -65,11 +72,18 @@ class TestEnumerable < Test::Unit::TestCase
       end
     end
 
-    assert_equal false, obj1.foo?
-    assert_equal true, obj2.foo?
-    assert_equal "a value", obj2.foo
+    obj1.foo?.assert == false
+    obj2.foo?.assert == true
+    obj2.foo.assert == "a value"
 
     result = [obj1, obj2].find_yield { |obj| obj.foo if obj.foo? }
-    assert_equal result, "a value"
+    result.assert == "a value"
+  end
+
+  unit :map_detect => "old alias for #find_yield" do
+    r = [true].map_detect{ |value| value }
+    r.assert == true
   end
+
 end
+

data/test/core/enumerable/test_frequency.rb

@@ -1,11 +1,11 @@
-require 'facets/enumerable/frequency.rb'
-require 'test/unit'
+covers 'facets/enumerable/frequency'
 
-class Test_Enumerable_Frequency < Test::Unit::TestCase
+testcase Enumerable do
 
-  def test_frequency
-    assert_equal( {'a'=>1,'b'=>1}, %w{a b}.frequency )
-    assert_equal( {'tom'=>1,'boy'=>1}, %w{tom boy}.frequency )
+  unit :frequency do
+    %w{a b}.frequency.assert == {'a'=>1,'b'=>1}
+    %w{a a b}.frequency.assert == {'a'=>2,'b'=>1}
   end
 
 end
+

data/test/core/enumerable/test_graph.rb

@@ -0,0 +1,38 @@
+covers 'facets/enumerable/graph'
+
+tests Enumerable do
+
+  unit :graph => "returns hash" do
+    a = { :a => 1, :b => 2, :c => 3 }
+    e = { :a => 2, :b => 3, :c => 4 }
+    r = a.graph{ |k,v| {k => v+1} }
+    r.assert == e
+  end
+
+  unit :graph => "hash of array" do
+    a = { :a => [1,2], :b => [2,3], :c => [3,4] }
+    e = { :a => 2, :b => 6, :c => 12 }
+    r = a.graph{ |k,v| [k, v[0]*v[1] ] }
+    r.assert == e
+  end
+
+  unit :graph => "array of array" do
+    a = [ [1,2], [2,3], [3,4] ]
+    e = { [1,2] => 2, [2,3] => 6, [3,4] => 12 }
+    r = a.graph{ |a| [a, a[0]*a[1] ] }
+    r.assert == e
+  end
+
+  unit :graph => "squares" do
+    numbers  = (1..3)
+    squares  = numbers.graph{ |n| [n, n*n] }
+    squares.assert == {1=>1, 2=>4, 3=>9}
+  end
+
+  unit :graph => "roots" do
+    numbers  = (1..3)
+    sq_roots = numbers.graph{ |n| [n*n, n] }
+    sq_roots.assert == {1=>1, 4=>2, 9=>3}
+  end
+
+end

data/test/core/enumerable/test_group_by.rb

@@ -1,30 +1,31 @@
-require 'facets/enumerable/group_by'
-require 'test/unit'
+covers 'facets/enumerable/group_by'
 
-class TC_Enumerable < Test::Unit::TestCase
+tests Enumerable do
 
-  def test_group_by_for_array
+  unit :group_by => "for array" do
     a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-    r = {0=>[0, 2, 4, 6, 8], 1=>[1, 3, 5, 7, 9]}
-    assert_equal(r, a.group_by{ |e| e % 2 }) #.each{|k, v| v.sort!})
+    e = {0=>[0, 2, 4, 6, 8], 1=>[1, 3, 5, 7, 9]}
+    r = a.group_by{ |x| x % 2 }  #.each{|k, v| v.sort!})
+    r.assert == e
   end
 
-  def test_group_by_for_hash
+  unit :group_by => "for hash" do
     h = {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9}
-    r = {0=>[[0, 0], [2, 2], [4, 4], [6, 6], [8, 8]], 1=>[[1, 1], [3, 3], [5, 5], [7, 7], [9, 9]]}
-    assert_equal(r, h.group_by{|k, v| v%2}.each{|k, v| v.sort!})
+    e = {0=>[[0, 0], [2, 2], [4, 4], [6, 6], [8, 8]], 1=>[[1, 1], [3, 3], [5, 5], [7, 7], [9, 9]]}
+    r = h.group_by{|k, v| v%2}.each{|k, v| v.sort!}
+    r.assert == e
   end
 
-  def test_group_by_for_range
-    x = (1..5).group_by{ |n| n % 3 }
-    o = { 0 => [3], 1 => [1, 4], 2 => [2,5] }
-    assert_equal( o, x )
+  unit :group_by => "for range" do
+    r = (1..5).group_by{ |n| n % 3 }
+    e = { 0 => [3], 1 => [1, 4], 2 => [2,5] }
+    r.assert == e
   end
 
-  def test_group_by_for_array_of_string
-    x = ["I had", 1, "dollar and", 50, "cents"].group_by{ |e| e.class }
-    o = { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
-    assert_equal( o, x )
+  unit :group_by => "for array of string" do
+    r = ["I had", 1, "dollar and", 50, "cents"].group_by{ |e| e.class }
+    e = { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
+    r.assert == e
   end
 
 end

data/test/core/enumerable/test_map_by.rb

@@ -0,0 +1,23 @@
+covers 'facets/enumerable/map_by'
+
+tests Enumerable do
+
+  unit :map_by do
+    a = [1,2,3,4,5]
+    r = a.map_by{ |e| [e % 2, e + 1] }
+    r.assert == { 0=>[3,5], 1=>[2,4,6] }
+  end
+
+  unit :map_by => "works well with a hash" do
+    h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
+    r = h.map_by{ |k,v| [v, k.downcase] }
+    r.assert == {1=>["a", "b", "c"], 2=>["d", "e"]}
+  end
+
+  unit :map_by => "if only a scalar is returned, #map_by acts like #group_by" do
+    h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2}
+    r = h.map_by{ |k,v| v }
+    r.assert == {1=>[["A",1], ["B",1], ["C",1]], 2=>[["D",2], ["E",2]]}
+  end
+
+end