facets 2.8.4 → 2.9.0.pre.1

data/test/core/module/test_set.rb

@@ -0,0 +1,26 @@
+covers 'facets/module/set'
+
+tests Module do
+
+  unit :set do
+    c = Class.new do
+      set :x, 10
+    end
+
+    c.x.assert == 10
+  end
+
+  unit :set do
+    h = 1
+    c = Class.new do
+      set :x do 
+        h += 1
+      end
+    end
+
+    c.x.assert == 2
+    c.x.assert == 3
+    c.x.assert == 4
+  end
+
+end

data/test/core/module/test_spacename.rb

@@ -1,13 +1,10 @@
-require 'facets/module/spacename.rb'
-require 'test/unit'
+covers 'facets/module/spacename'
 
-class TestModuleSpaceName < Test::Unit::TestCase
+tests Module do
 
-  def test_spacename
-    assert_equal( 'Test::Unit', Test::Unit::TestCase.spacename )
-    assert_equal( 'Test::Unit', ::Test::Unit::TestCase.spacename )
-    assert_equal( '', Test.spacename )
-    assert_equal( '', ::Test.spacename )
+  unit :spacename do
+    Lemon::TestCase.spacename.assert == 'Lemon'
+    Lemon.spacename.assert == ''  # should this be nil ?
   end
 
 end

data/test/core/module/test_to_obj.rb

@@ -0,0 +1,16 @@
+covers 'facets/module/to_obj'
+
+tests Module do
+
+  unit :to_obj do
+    m = Module.new do
+      def x; "x"; end
+      def y; "y"; end
+    end
+    o = m.to_obj
+    o.x.assert == "x"
+    o.y.assert == "y"
+  end
+
+end
+

data/test/core/module/test_wrap_method.rb

@@ -1,24 +1,24 @@
-require 'facets/module/wrap_method'
-require 'test/unit'
+covers 'facets/module/wrap_method'
 
-class Test_Module_WrapMethod < Test::Unit::TestCase
+testcase Module do
 
-  def a; "A"; end
+  unit :wrap_method do
+    c = Class.new do
+      def a; "A"; end
+      wrap_method(:a) { |old| old.call + "B" }
+    end
 
-  wrap_method(:a) { |old| old.call + "B" }
-
-  def test_wrap_method
-    assert_equal( "AB", a )
+    c.new.a.assert == "AB"
   end
 
-  # wrap
-
-  def b; "B"; end
+  unit :wrap do
+    c = Class.new do
+      def b; "B"; end
+      wrap(:b) { |old| old.call + "C" }
+    end
 
-  wrap(:b) { |old| old.call + "C" }
-
-  def test_wrap
-    assert_equal( "BC", b )
+    c.new.b.assert == "BC"
   end
 
 end
+

data/test/core/nilclass/test_to_f.rb

@@ -1,10 +1,9 @@
-require 'facets/nilclass/to_f'
-require 'test/unit'
+covers 'facets/nilclass/to_f'
 
-class TC_NilClass_To_F < Test::Unit::TestCase
+testcase NilClass do
 
-  def test_to_f
-    assert_equal( 0, nil.to_f )
+  unit :to_f do
+    nil.to_f.assert == 0
   end
 
 end

data/test/core/numeric/test_approx.rb

@@ -1,9 +1,8 @@
-require 'facets/numeric/approx'
-require 'test/unit'
+covers 'facets/numeric/approx'
 
-class TestRound < Test::Unit::TestCase
+testcase Numeric do
 
-  def test_approx?
+  unit :approx? do
     f = 10.006
     assert( f.approx?(10.01) )
     assert( f.approx?(10, 0.1) )
@@ -11,3 +10,4 @@ class TestRound < Test::Unit::TestCase
   end
 
 end
+

data/test/core/numeric/test_distance.rb

@@ -1,12 +1,11 @@
-require 'facets/numeric/distance.rb'
-require 'test/unit'
+covers 'facets/numeric/distance'
 
-class TestNumericDistance < Test::Unit::TestCase
+testcase Numeric do
 
-  def test_distance
-    assert_equal( 4, 10.distance(6) )
-    assert_equal( 2, 10.distance(8) )
-    assert_equal( -2, 7.distance(9) )
+  unit :distance do
+    10.distance(6).assert == 4
+    10.distance(8).assert == 2
+     7.distance(9).assert == -2
   end
 
 end

data/test/core/numeric/test_length.rb

@@ -0,0 +1,12 @@
+covers 'facets/numeric/length'
+
+testcase Numeric do
+
+  unit :length do
+    (0..10).each do |power|
+      power.length.assert == power
+    end
+  end
+
+end
+

data/test/core/numeric/test_round.rb

@@ -1,49 +1,58 @@
-require 'facets/numeric/round.rb'
-require 'test/unit'
+covers 'facets/numeric/round'
 
-class TestRound < Test::Unit::TestCase
+testcase Numeric do
 
-  def setup
-    @f0 = [ 0, 10, 15, 105 ]
-    @f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+  f0 = [ 0, 10, 15, 105 ]
+
+  unit :round_at => "1" do
+    fr = f0.collect{ |f| f.round_at(1) }
+    fr.assert == [0,10,15,105]
+  end
+
+  unit :round_at => "2" do
+    fr = f0.collect { |f| f.round_at(2) }
+    fr.assert == [0,10,15,105]
   end
 
-  def test_round_at_arg1
-    fr = @f0.collect{ |f| f.round_at(1) }
-    assert_equal( [0,10,15,105], fr )
-    fr = @f1.collect { |f| f.round_at(1) }
-    assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+  unit :round_to => "0.1" do
+    fr = f0.collect { |f| f.round_to(0.1) }
+    fr.assert == [0,10,15,105]
   end
 
-  def test_round_at_arg2
-    fr = @f0.collect { |f| f.round_at(2) }
-    assert_equal( [0,10,15,105], fr )
-    fr = @f1.collect { |f| f.round_at(2) }
-    assert_equal( [10.1,10.01,10.9,10.09,10.5,10.05,10.49], fr )
+  unit :round_to => "10" do
+    fr = f0.collect { |f| f.round_to(10) }
+    fr.assert == [0,10,20,110]
   end
 
-  #def test_round_off
-  #  assert_equal( 1.0, 1.2.round_off )
-  #  assert_equal( 2.0, 1.8.round_off )
+  #unit :round_off do
+  #  1.2.round_off.assert == 1.0
+  #  1.8.round_off.assert == 2.0
   #end
 
-  def test_round_to_arg1
-    fr = @f0.collect { |f| f.round_to(0.1) }
-    assert_equal( [0,10,15,105], fr )
-    fr = @f1.collect { |f| f.round_to(0.1) }
-    assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+end
+
+testcase Float do
+
+  f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+
+  unit :round_at => "1" do
+    fr = f1.collect { |f| f.round_at(1) }
+    fr.assert == [10.1,10.0,10.9,10.1,10.5,10.1,10.5]
   end
 
-  def test_round_to_arg10
-    fr = @f0.collect { |f| f.round_to(10) }
-    assert_equal( [0,10,20,110], fr )
-    fr = @f1.collect { |f| f.round_to(10) }
-    assert_equal( [10,10,10,10,10,10,10], fr )
+  unit :round_at => "2" do
+    fr = f1.collect { |f| f.round_at(2) }
+    fr.assert == [10.1,10.01,10.9,10.09,10.5,10.05,10.49]
   end
 
-  #def test_round_off
-  #  assert_equal( 1.0, 1.2.round_off )
-  #  assert_equal( 2.0, 1.8.round_off )
-  #end
+  unit :round_to => "0.1" do
+    fr = f1.collect { |f| f.round_to(0.1) }
+    fr.assert == [10.1,10.0,10.9,10.1,10.5,10.1,10.5]
+  end
+
+  unit :round_to => "10" do
+    fr = f1.collect { |f| f.round_to(10) }
+    fr.assert == [10,10,10,10,10,10,10]
+  end
 
 end

data/test/core/numeric/test_spacing.rb

@@ -1,12 +1,13 @@
-require 'facets/numeric/spacing'
-require 'test/unit'
- 
-class TC_Numeric_spacing < Test::Unit::TestCase
-  def test_spacing
+covers 'facets/numeric/spacing'
+
+testcase Numeric do
+
+  unit :spacing do
     samples = [-10.5, -3, 3, 1.0e14, 10000, 14.5e10]
     samples.each do |numeric_item|
-      assert numeric_item.to_s.size == numeric_item.spacing
-      assert numeric_item.spacing.kind_of?(Integer)
+      numeric_item.spacing.assert == numeric_item.to_s.size
+      numeric_item.spacing.assert.kind_of?(Integer)
     end
   end
+
 end

data/test/core/proc/test_bind.rb

@@ -1,17 +1,16 @@
-require 'facets/proc/bind.rb'
-require 'test/unit'
+covers 'facets/proc/bind'
 
-class TestProc < Test::Unit::TestCase
+testcase Proc do
 
   # Not sure why this is thread critical?
-
-  def test_memory_leak
+  unit :bind => "thread critial" do
     a = 2
     tproc = lambda { |x| x + a }
     99.times {
       tmethod = tproc.bind(self) #to_method
-      assert_equal( 3, tmethod.call(1) )
+      tmethod.call(1).assert == 3
     }
+
     meths = (
       Object.instance_methods +
       Object.public_instance_methods +
@@ -20,7 +19,8 @@ class TestProc < Test::Unit::TestCase
     )
     meths = meths.select{ |s| s.to_s =~ /^_bind_/ }
     #meths = Symbol.all_symbols.select { |s| s.to_s =~ /^_bind_/ }  # why?
-    assert_equal( 0, meths.size )
+
+    meths.size.assert == 0
   end
 
 end

data/test/core/proc/test_bind_to.rb

@@ -0,0 +1,13 @@
+covers 'facets/proc/bind_to'
+
+testcase Proc do
+
+  unit :bind_to => '' do
+     a = [1,2,3]
+     p1 = Proc.new{ join(' ') }
+     p2 = p1.bind_to(a)
+     p2.call.assert == '1 2 3'
+  end
+
+end
+

data/test/core/proc/test_compose.rb

@@ -1,20 +1,19 @@
-require 'facets/proc/compose.rb'
-require 'test/unit'
+covers 'facets/proc/compose'
 
-class TestProc < Test::Unit::TestCase
+testcase Proc do
 
-  def test_compose
+  unit :compose do
     a = lambda { |x| x + 4 }
     b = lambda { |y| y / 2 }
-    assert_equal( 6, (a.compose(b)).call(4) )
-    assert_equal( 4, (b.compose(a)).call(4) )
+    (a.compose(b)).call(4).assert == 6
+    (b.compose(a)).call(4).assert == 4
   end
 
-  def test_compose_op
+  unit :* do
     a = lambda { |x| x + 4 }
     b = lambda { |y| y / 2 }
-    assert_equal( 6, (a * b).call(4) )
-    assert_equal( 4, (b * a).call(4) )
+    (a * b).call(4).assert == 6
+    (b * a).call(4).assert == 4
   end
 
 end

data/test/core/proc/test_curry.rb

@@ -1,35 +1,33 @@
-# Test lib/more/ext/facets/proc/curry.rb
+covers 'facets/proc/curry'
 
-require 'facets/proc/curry.rb'
-require 'test/unit'
+testcase Proc do
 
-class TestProcCurry < Test::Unit::TestCase
-
-  def test_curry_simple
+  unit :curry do
     f = Proc.new{ |a,b,c| a + b + c }
     c = f.curry
-    assert_equal( 6, c[1][2][3] )
+    c[1][2][3].assert == 6
   end
 
-  def test_curry_arguments
+  unit :curry => "with arguments" do
     f = Proc.new{ |a,b| a**b }
     c = f.curry(0)
-    assert_equal( 8, c[2][3] )
+    c[2][3].assert == 8
 
     f = Proc.new{ |a,b| a**b }
     c = f.curry(1)
-    assert_equal( 9, c[2][3] )
+    c[2][3].assert == 9
   end
 
-  def test_inclass_scope
+  unit :curry => "with in class scope" do
     # first test the lambda
     org = lambda{ |y, x| x + " " + y }
     foo = org.curry['yeah']
-    assert_equal('boo yeah', foo['boo'])
+    foo['boo'].assert == 'boo yeah'
+
     # now test it as a method definition
     baz = Class.new
     baz.__send__(:define_method, 'foo', foo)
-    assert_equal('boo yeah',baz.new.foo('boo'))
+    baz.new.foo('boo').assert == 'boo yeah'
   end
 
 end

data/test/core/proc/test_partial.rb

@@ -0,0 +1,23 @@
+covers 'facets/proc/partial'
+
+tests Proc do
+
+  unit :partial => "first argument" do
+    f = Proc.new{ |a,b,c| a + b + c }
+    n = f.partial(NA,2,3)
+    n[1].assert == 6
+  end
+
+  unit :partial => "second argument" do
+    f = Proc.new{ |a,b,c| a + b + c }
+    n = f.partial(1,NA,3)
+    n[2].assert == 6
+  end
+
+  unit :partial => "third argument" do
+    f = Proc.new{ |a,b,c| a + b + c }
+    n = f.partial(1,2,NA)
+    n[3].assert == 6
+  end
+
+end

data/test/core/proc/test_to_method.rb

@@ -1,25 +1,38 @@
-require 'facets/proc/to_method.rb'
-require 'test/unit'
+covers 'facets/proc/to_method'
 
-class TestProc < Test::Unit::TestCase
+testcase Proc do
 
-  def test_to_method
-    a = 2
-    tproc = proc { |x| x + a }
-    tmeth = tproc.to_method(self, :tryit)
+  unit :to_method do
+    o = Object.new
+    tproc = proc { |x| x + 2 }
 
-    assert_equal( 3, tmeth.call(1) )
-    assert_respond_to( self, :tryit )
-    assert_equal( 3, tryit(1) )
+    tmeth = tproc.to_method(o, :tryit)
+
+    tmeth.call(1).assert == 3
+    o.assert.respond_to?(:tryit)
+    o.tryit(1).assert == 3
   end
 
-  def test_to_method_with_immutable
+  unit :to_method => "with immutable object" do
+    o = :foo
     tproc = proc{ self }
-    tmeth = tproc.to_method(:foo, :tryit)
 
-    assert_equal(:foo, tmeth.call)
-    assert_respond_to( :foo, :tryit )
-    assert_equal( :foo, :foo.tryit )
+    tmeth = tproc.to_method(o, :tryit)
+
+    tmeth.call.assert == :foo
+    o.assert.respond_to?(:tryit)
+    o.tryit.assert == :foo
+  end
+
+  unit :to_method => "ensure method is in object scope" do
+    o = Struct.new(:a).new(1)
+    tproc = proc{ a }
+
+    tmeth = tproc.to_method(o, :tryit)
+
+    tmeth.call.assert == 1
+    o.assert.respond_to?(:tryit)
+    o.tryit.assert == 1
   end
 
 end