facets 2.8.4 → 2.9.0.pre.1

data/test/core/hash/test_swap.rb

@@ -1,11 +1,11 @@
-require 'facets/hash/swap.rb'
-require 'test/unit'
+covers 'facets/hash/swap'
 
-class TestHashSwap < Test::Unit::TestCase
+testcase Hash do
 
-  def test_swap!
+  unit :swap! do
     h = { :a=>1, :b=>2 }
-    assert_equal( { :a=>2, :b=>1 }, h.swap!(:a, :b) )
+    h.swap!(:a, :b).assert == { :a=>2, :b=>1 }
   end
 
 end
+

data/test/core/hash/test_symbolize_keys.rb

@@ -1,20 +1,18 @@
-# Test for facets/hash/symbolize_keys.rb
+covers 'facets/hash/symbolize_keys'
 
-require 'facets/hash/symbolize_keys.rb'
-require 'test/unit'
+testcase Hash do
 
-class TestSymbolizeKeys < Test::Unit::TestCase
-
-  def test_symbolize_keys
+  unit :symbolize_keys do
     foo = { 'a'=>1, 'b'=>2 }
-    assert_equal( { :a=>1, :b=>2 }, foo.symbolize_keys )
-    assert_equal( { "a" =>1, "b"=>2 }, foo )
+    foo.symbolize_keys == { :a=>1, :b=>2 }
+    foo.assert == { "a" =>1, "b"=>2 }
   end
 
-  def test_symbolize_keys!
+  unit :symbolize_keys! do
     foo = { 'a'=>1, 'b'=>2 }
-    assert_equal( { :a=>1, :b=>2 }, foo.symbolize_keys! )
-    assert_equal( { :a=>1, :b=>2 }, foo  )
+    foo.symbolize_keys!.assert == { :a=>1, :b=>2 }
+    foo.assert == { :a=>1, :b=>2 }
   end
 
 end
+

data/test/core/hash/test_to_mod.rb

@@ -0,0 +1,20 @@
+covers 'facets/hash/to_mod'
+
+testcase Hash do
+
+  unit :to_mod do
+    h = { :a=>1, :b=>2 }
+    m = h.to_mod
+    Module.assert === m
+  end
+
+  unit :to_mod => "check methods" do
+    h = { :a=>1, :b=>2 }
+    m = h.to_mod
+    x = Class.new{ include m }.new
+    x.a.assert == 1
+    x.b.assert == 2
+  end
+
+end
+

data/test/core/hash/test_to_proc.rb

@@ -0,0 +1,19 @@
+covers 'facets/hash/to_proc'
+
+testcase Hash do
+
+  unit :to_proc do
+    c = Class.new do
+      attr_accessor :a
+    end
+
+    h = {:a => 1}
+    o = c.new
+
+    h.to_proc.call(o)
+
+    o.a.assert == 1
+  end
+  
+end
+

data/test/core/hash/test_to_struct.rb

@@ -0,0 +1,18 @@
+covers 'facets/hash/to_struct'
+
+testcase Hash do
+
+  unit :to_struct do
+    h = {:name=>"Dan","age"=>33,"rank"=>"SrA","grade"=>"E4"}
+    s = h.to_struct("Foo")
+
+    s.name.assert  = "Dan"
+    s.age.assert   = 33
+    s.rank.assert  = "SrA"
+    s.grade.assert = "E4"
+
+    #Foo.assert.is_a?(Struct) ?
+  end
+  
+end
+

data/test/core/hash/test_traverse.rb

@@ -1,21 +1,20 @@
-require 'facets/hash/traverse'
-require 'test/unit'
+covers 'facets/hash/traverse'
 
-class TC_Hash_Traverse < Test::Unit::TestCase
+testcase Hash do
 
-  def test_traverse
+  unit :traverse do
     h = { "A" => "x", "B" => "y" }
-    h2 = h.traverse { |k,v| [k.downcase, v.upcase] }
-    e = { "a" => "X", "b" => "Y" }
-    assert_not_equal( h, h2 )
-    assert_equal( e, h2 )
+    j = h.traverse{ |k,v| [k.downcase, v.upcase] }
+    x = { "a" => "X", "b" => "Y" }
+    j.refute == h
+    j.assert == x
   end
 
-  def test_traverse!
+  unit :traverse! do
     h = { "A" => "x", "B" => "y" }
-    h.traverse! { |k,v| [k.downcase, v.upcase] }
-    e = { "a" => "X", "b" => "Y" }
-    assert_equal( e, h )
+    h.traverse!{ |k,v| [k.downcase, v.upcase] }
+    x = { "a" => "X", "b" => "Y" }
+    h.assert == x
   end
 
 end

data/test/core/hash/test_update_each.rb

@@ -1,13 +1,12 @@
-require 'facets/hash/update_each'
-require 'test/unit'
+covers 'facets/hash/update_each'
 
-class TC_Hash_Update_Each < Test::Unit::TestCase
+testcase Hash do
 
-  def test_update_each
+  unit :update_each do
     a = { :a => 1, :b => 2, :c => 3 }
-    e = { :a => 2, :b => 3, :c => 4 }
+    x = { :a => 2, :b => 3, :c => 4 }
     a.update_each{ |k,v| { k => v+1 } }
-    assert_equal( e, a )
+    a.assert == x
   end
 
 end

data/test/core/hash/test_update_keys.rb

@@ -1,18 +1,17 @@
-require 'facets/hash/update_keys'
-require 'test/unit'
+covers 'facets/hash/update_keys'
 
-class TC_Hash_Update_Keys < Test::Unit::TestCase
+testcase Hash do
 
-  def test_update_keys_01
+  unit :update_keys do
     h = { 'A' => 1, 'B' => 2 }
     h.update_keys{ |k| k.downcase }
-    assert_equal( { 'a' => 1, 'b' => 2 }, h)
+    h.assert == {'a' => 1, 'b' => 2}
   end
 
-  def test_update_keys_02
+  unit :update_keys do
     h = { :a => 1, :b => 2 }
     h.update_keys{ |k| "#{k}!" }
-    assert_equal( { "a!" => 1, "b!" => 2 }, h)
+    h.assert == {'a!' => 1, 'b!' => 2}
   end
 
 end

data/test/core/hash/test_update_values.rb

@@ -1,12 +1,12 @@
-require 'facets/hash/update_values'
-require 'test/unit'
+covers 'facets/hash/update_values'
 
-class TC_Hash_Update_Values < Test::Unit::TestCase
+testcase Hash do
 
-  def test_update_values
-    h = { 1 => 'A', 2 => 'B' }
+  unit :update_values do
+    h = {1 => 'A', 2 => 'B'}
     h.update_values{ |v| v.downcase }
-    assert_equal( { 1 => 'a', 2 => 'b' }, h )
+    h.assert == {1 => 'a', 2 => 'b'}
   end
 
 end
+

data/test/core/hash/test_weave.rb

@@ -1,16 +1,12 @@
-# Test for facets/hash/weave
+covers 'facets/hash/weave'
 
-require 'facets/hash/weave.rb'
+testcase Hash do
 
-require 'test/unit'
-
-class TestHashWeave < Test::Unit::TestCase
-
-  def test_weave
+  unit :weave do
     b = { :a=>1, :b=>[1,2,3], :c=>{ :x=>'X' } }
     c = { :a=>2, :b=>[4,5,6], :c=>{ :x=>'A', :y => 'B' } }
-    r = { :a=>2, :b=>[1,2,3,4,5,6], :c=>{ :x => 'A', :y => 'B' } }
-    assert_equal( r, b.weave(c) )
+    x = { :a=>2, :b=>[1,2,3,4,5,6], :c=>{ :x => 'A', :y => 'B' } }
+    b.weave(c).assert == x
   end
 
 end

data/test/core/hash/test_zipnew.rb

@@ -1,12 +1,11 @@
-require 'facets/hash/zipnew'
-require 'test/unit'
+covers 'facets/hash/zipnew'
 
-class TC_Hash_ZipNew < Test::Unit::TestCase
+testcase Hash do
 
-  def test_zipnew
+  metaunit :zipnew do
     a = [1,2,3]
     b = [4,5,6]
-    assert_equal( {1=>4,2=>5,3=>6}, Hash.zipnew(a,b) )
+    Hash.zipnew(a,b).assert == {1=>4,2=>5,3=>6}
   end
 
 end

data/test/core/indexable_tc.rb

@@ -0,0 +1,177 @@
+covers 'facets/indexable'
+covers 'facets/array/indexable'
+
+tests Indexable do
+
+  unit :head do
+    [1,2,3].head.assert == [1]
+  end
+
+  unit :tail do
+    [1,2,3].tail.assert == [2,3]
+  end
+
+  unit :foot do
+    [1,2,3].foot.assert == [3]
+  end
+
+  unit :body do
+    [1,2,3].body.assert == [1,2]
+  end
+
+  unit :mid do
+    %w{W o r l d}.mid.assert == 'r'
+    %w{W o r l d}.mid(1).assert == 'l'
+    %w{W o r l d}.mid(-1).assert == 'o'
+  end
+
+  unit :mid do
+    a = [1,2,3,4,5]
+    b = [1,2,3,4,5,6]
+    a.mid.assert == 3
+    b.mid.assert == 4
+    a.mid(1).assert == 4
+    b.mid(1).assert == 5
+    b.mid(2).assert == 6
+    b.mid(-1).assert == 3
+  end
+
+  unit :middle do
+    [1,2,3,4,5].middle.assert == [3]
+    [1,2,3,4,5,6].middle.assert == [3,4]
+  end
+
+  unit :middle do
+    %w{W o r l d}.middle.assert == ['r']
+    %w{W o r l d y}.middle.assert == ['r', 'l']
+  end
+
+  unit :middle do
+    [1,2,3,4,5].middle(1).assert == [2,3,4]
+    [1,2,3,4,5,6].middle(1).assert == [2,3,4,5]
+  end
+
+  unit :from do
+    %w{W o r l d}.from(3).assert == %w{l d}
+  end
+
+  unit :thru => "single parameter" do
+    a = [1,2,3,4,5]
+    r = a.thru(3)
+    r.assert == [1,2,3,4]
+  end
+
+  unit :thru => "dual parameter" do
+    a = [1,2,3,4,5]
+    r = a.thru(3,4)
+    r.assert == [4,5]
+  end
+
+  unit :thru do
+    [0,1,2,3,4,5].thru(2,4).assert == [2,3,4]
+    [0,1,2,3,4,5].thru(0,1).assert == [0,1]
+  end
+
+  # to be deprecated
+  unit :index_of do
+    [1,2,3,4].index_of{ |e| e == 3 }.assert == 2
+    [1,2,3,4].index_of{ |e| e > 3 }.assert == 3
+  end
+
+  unit :first= do
+    a = [1,2,3]
+    a.first = 9
+    a.assert == [9,2,3]
+  end
+
+  unit :last= do
+    a = [1,2,3]
+    a.last = 9
+    a.assert == [1,2,9]
+  end
+
+  unit :ends do
+    [1,2,3,4,5].ends.assert == 4
+  end
+
+  unit :pos do
+    [1,2,3,4,5].pos(1).assert == 0
+    [1,2,3,4,5].pos(-1).assert == 4
+  end
+
+  unit :range do
+    ['a','b','c','d'].range.assert == (0..3)
+    ['a','b','c','d'].range('b','d').assert == (1..3)
+  end
+
+  unit :range do
+    a = [1,2,3,4,5]
+    b = [1,2,3,4,5,6]
+    a.range.assert == (0..4)
+    b.range.assert == (0..5)
+    a.range(2,4).assert == (1..3)
+    b.range(2,3).assert == (1..2)
+    b.range(4,2).assert == (3..1)
+  end
+
+  # We can't use an Array to test the following methods b/c
+  # Array handles them specially, either for efficency reasons,
+  # or becuase the have been added to Ruby as of 1.8.7+.
+
+  context "special Indexable object" do
+    Class.new do
+      include Indexable
+      def initialize(*a); @a = a; end
+      def slice(*a)  ; @a.slice(*a)  ; end
+      def splice(*a) ; @a.splice(*a) ; end
+      def size       ; @a.size       ; end
+      def to_a       ; @a            ; end
+    end
+  end
+
+  unit :first do |c|
+    a = c.new(1,2,3,4,5)
+    r = a.first(3)
+    r.assert == [1,2,3]
+  end
+
+  unit :last do |c|
+    a = c.new(1,2,3,4,5)
+    r = a.last(3)
+    r.assert == [3,4,5]
+  end
+
+  unit :first! do |c|
+    a = c.new(1,2,3,4,5)
+    e = a.first!
+    e.assert == 1
+    a.to_a.assert == [2,3,4,5]
+  end
+
+  unit :last! do |c|
+    a = c.new(1,2,3,4,5)
+    e = a.last!
+    e.assert == 5
+    a.to_a.assert == [1,2,3,4]
+  end
+
+  unit :index do |c|
+    c.new(1,2,3,4).index{ |e| e == 3 }.assert == 2
+    c.new(1,2,3,4).index{ |e| e > 3 }.assert == 3
+  end
+
+  #unit :op_fetch do
+  #  a = ['a','b','c','d','e','f']
+  #  assert_equal( ['b','f'], a[[1,-1]] )
+  #end
+  #
+  #unit :op_store do
+  #  a = ['a','o','z']
+  #  a[[0,2]] = ['A','Z']
+  #  assert_equal( ['A','o','Z'], a )
+  #  a[[0,-1]] = ['W','Y']
+  #  assert_equal( ['W','o','Y'], a )
+  #end
+
+end
+

data/test/core/integer/test_bitmask.rb

@@ -1,53 +1,60 @@
-# Test for facets/integer/bitmask
+covers 'facets/integer/bitmask'
 
-require 'facets/bitmask.rb'
+testcase Integer do
 
-require 'test/unit'
-
-class TestIntegerBitmask < Test::Unit::TestCase
-
-  def test_bit
-    assert_equal( 1, 0.bit(0) )
-    assert_equal( 2, 0.bit(1) )
-    assert_equal( 4, 0.bit(2) )
-    assert_equal( 8, 0.bit(3) )
+  unit :bit do
+    0.bit(0).assert == 1
+    0.bit(1).assert == 2
+    0.bit(2).assert == 4
+    0.bit(3).assert == 8
   end
 
-  def test_negate_bit
-    assert_equal( 0, 1.bit(~0) )
-    assert_equal( 0, 2.bit(~1) )
-    assert_equal( 0, 4.bit(~2) )
-    assert_equal( 0, 8.bit(~3) )
+  unit :bit => "negate" do
+    1.bit(~0).assert == 0
+    2.bit(~1).assert == 0
+    4.bit(~2).assert == 0
+    8.bit(~3).assert == 0
   end
 
-  def test_clear_bit
-    assert_equal( 0, 1.clear_bit(0) )
-    assert_equal( 0, 2.clear_bit(1) )
-    assert_equal( 0, 4.clear_bit(2) )
-    assert_equal( 0, 8.clear_bit(3) )
+  unit :bit_clear do
+    1.bit_clear(0).assert == 0
+    2.bit_clear(1).assert == 0
+    4.bit_clear(2).assert == 0
+    8.bit_clear(3).assert == 0
   end
 
-  def test_bit?
+  unit :bit? do
     a = 8
     assert(! a.bit?(0))
     assert(! a.bit?(1))
     assert(! a.bit?(2))
-    assert(a.bit?(3))
+    assert(  a.bit?(3))
     assert(! a.bit?(4))
     assert(! a.bit?(5))
   end
 
-  def test_bitmask
+  unit :bitmask do
     a =  1
     m = Bit(4)
     a = a.bitmask(m)
-    assert_equal( 17, a )
+    a.assert == 17
     assert( a.bitmask?(m) )
   end
 
-  def test_Bit
+  unit :bitmask? do
+    7.assert.bitmask?(7)
+    7.assert.bitmask?(5)
+    8.refute.bitmask?(3)
+  end
+
+end
+
+testcase Kernel do
+
+  unit :Bit do
     n = Bit(4)
-    assert_equal(16, n)
+    n.assert == 16
   end
 
 end
+