facets 0.6.3

data/test/array/tc_array.rb

@@ -0,0 +1,234 @@
+
+require 'test/unit'
+
+require 'facet/array/[[]]'
+require 'facet/array/at_rand'
+require 'facet/array/combinations'
+require 'facet/array/delete_values'
+require 'facet/array/first&last'
+require 'facet/array/head&tail'
+require 'facet/array/last_index'
+require 'facet/array/middle'
+require 'facet/array/pos'
+require 'facet/array/pull'
+require 'facet/array/range'
+#require 'facet/array/remove'
+require 'facet/array/rotate'
+require 'facet/array/select!'
+require 'facet/array/shuffle'
+require 'facet/array/to_b'
+require 'facet/array/to_h'
+
+
+class TC_Array < Test::Unit::TestCase
+
+  # []
+  
+  def test_square_brackets
+    a = ['a','b','c','d','e','f']
+    assert_equal( ['b','f'], a[[1,-1]] )
+    #assert_equal( ['a','c','e'], a[0,2,4] )
+  end
+  
+  # at_rand
+  
+  def test_at_rand!
+    a = ['a','b','c']
+    assert_equal( 1, a.at_rand.length )
+    assert_equal( 3, a.length )
+    a = ['a','b','c']
+    assert_equal( 1, a.at_rand!(1).length )
+    assert_equal( 2, a.length )
+    a = ['a','b','c']
+    assert_equal( 2, a.at_rand!(2).length )
+    assert_equal( 1, a.length )
+    a = ['a','b','c']
+    assert_equal( 3, a.pick(3).length )
+    assert_equal( 0, a.length )
+    a = ['a','b','c']
+    assert_equal( 3, a.pick(4).length )
+    assert_equal( 0, a.length )
+  end
+
+  def test_at_rand
+    a = [1,2,3,4,5]
+    20.times{ assert_nothing_raised{ a.at_rand } }
+    20.times{ assert( a.include?( a.at_rand ) ) }
+    a = [1,2,3,4,5]
+    20.times{ assert_nothing_raised{ a.at_rand(1) } }
+    assert_equal( 3, a.at_rand(3).length )
+  end
+
+  # combinations
+  
+  def test_combinations
+    a = [1,2]
+    b = [3,4]
+    r = Array.combinations(a,b)
+    assert_equal( [[1,3],[1,4],[2,3],[2,4]], r )
+  end
+  
+  def test_each_combination
+    r = []
+    a = [1,2,3,4]
+    a.each_combination(2){ |a,b| r << [a,b] }
+    assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
+  end
+  
+  def test_each_unique_pair
+    r = []
+    a = [1,2,3,4]
+    a.each_unique_pair{ |a,b| r << [a,b] }
+    assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
+  end
+
+  # delete_values
+  
+  def test_delete_values
+    a = [1,2,3,4]
+    assert_equal( [1,2], a.delete_values(1,2) )
+    assert_equal( [3,4], a )
+  end
+  
+  def test_delete_values_at
+    a = [1,2,3,4]
+    assert_equal( [2,3], a.delete_values_at(1,2) )
+    assert_equal( [1,4], a )
+    a = [1,2,3,4]
+    assert_equal( [1,2,3], a.delete_values_at(0..2) )
+    assert_equal( [4], a )
+  end
+  
+  # first&last
+  
+  def test_first_eq
+    a = [1,2]
+    a.first = 0
+    assert_equal( [0,2], a )
+  end
+  
+  def test_last_eq
+    a = [1,2]
+    a.last = 3
+    assert_equal( [1,3], a )
+  end
+  
+  def test_first!
+    a = [1,2]
+    a.first! 0
+    assert_equal( [0,1,2], a )
+  end
+  
+  def test_last!
+    a = [1,2]
+    a.last! 3
+    assert_equal( [1,2,3], a )
+  end
+
+  # last_index
+
+  def test_last_index
+    assert_equal( [1,2,3,4,5].last_index, 4 )
+  end
+
+  # middle
+  
+  def test_middle
+    a = [1,2,3,4,5]
+    b = [1,2,3,4,5,6]  
+    assert_equal( 3, a.middle )
+    assert_equal( 4, b.middle )
+    assert_equal( 4, a.middle(1) )
+    assert_equal( 5, b.middle(1) )
+    assert_equal( 6, b.middle(2) )
+    assert_equal( 3, b.middle(-1) )
+  end 
+  
+  # pos
+
+  def test_pos
+    a = [1,2,3,4,5]
+    assert_equal( a.pos(1), 0 )
+    assert_equal( a.pos(-1), 4 )
+  end
+
+  # pull
+  
+  def test_pull
+    a = [1,2,3,4,5]
+    assert_equal( 1, a.pull )
+    assert_equal( [2,3,4,5], a )
+  end
+
+  def test_put
+    a = [2,3,4,5]
+    assert_equal( [1,2,3,4,5], a.put(1) )
+  end
+    
+  # range
+  
+  def test_range
+    a = [1,2,3,4,5]
+    b = [1,2,3,4,5,6]
+    assert_equal( (0..4), a.range )
+    assert_equal( (0..5), b.range )
+    assert_equal( (1..3), a.range(2,4) )
+    assert_equal( (1..2), b.range(2,3) )
+    assert_equal( (3..1), b.range(4,2) )
+  end
+  
+  # select!
+  
+  def test_select!
+    a = [1,2,3,4,5,6,7,8,9,10]
+    a.select!{ |e| e % 2 == 0 }
+    assert_equal( [2,4,6,8,10], a)
+  end
+  
+  # shuffle
+  
+  def test_shuffle
+    a = [1,2,3,4,5]
+    100.times{ assert_nothing_raised{ a.shuffle } }
+  end
+  
+  # head & tail
+
+  def test_tail
+    a = [1,2,3,4,5]
+    assert_equal( [2,3,4,5], a.tail )
+  end
+
+  def test_head
+    a = [1,2,3,4,5]
+    assert_equal( [1], a.head )
+  end
+
+  def test_foot
+    a = [1,2,3,4,5]
+    assert_equal( [5], a.foot )
+  end
+
+  def test_body
+    a = [1,2,3,4,5]
+    assert_equal( [1,2,3,4], a.body )
+  end
+  
+  # to_b
+  
+  def test_to_b
+    a = []
+    assert_equal( false, a.to_b )
+  end
+
+  # to_h
+  
+  def to_h
+    a = [[1,2],[3,4],[5,6]]
+    assert_equal( { 1=>2, 3=>4, 5=>6 }, a.to_h )
+    k = [1,3,5]
+    v = [2,4,6]
+    assert_equal( { 1=>2, 3=>4, 5=>6 }, k.to_h(v) )
+  end
+  
+end

data/test/array/tc_brackets.rb

@@ -0,0 +1,16 @@
+
+require 'test/unit'
+
+require 'facet/array/[]'
+
+
+class TC_Array < Test::Unit::TestCase
+
+  # []
+  
+  def test_square_brackets
+    a = ['a','b','c','d','e','f']
+    assert_equal( ['a','c','e'], a[0,2,4] )
+  end
+ 
+end

data/test/binding/tc_binding.rb

@@ -0,0 +1,77 @@
+
+require 'test/unit'
+
+require "facet/binding/eval"
+require "facet/binding/self"
+require "facet/binding/caller"
+require "facet/binding/defined?"
+require "facet/binding/called"
+require "facet/binding/local_variables"
+require "facet/binding/lineno"
+require "facet/binding/delegate!"
+
+
+class TC_Binding < Test::Unit::TestCase
+
+  def setup
+    a = 1
+    b = 2
+    x = "hello"
+    # the line number must be updated if it moves
+    @bind = binding; @this_line_no = 21
+  end
+
+  # eval
+
+  def test_eval
+    assert_equal( "hello", @bind.eval("x") )
+  end
+
+  def test_filename
+    assert_equal( 'tc_binding.rb', File.basename( @bind.filename ) )
+  end
+
+  def test_lineno
+    assert_equal( @this_line_no, @bind.lineno )
+  end
+
+  # called
+  
+  def test_called
+    assert_equal( :setup, @bind.called )
+  end
+
+  # class (not really a test of Facets)
+  
+  def test_class
+    assert_equal( TC_Binding, @bind.self.class )
+  end
+  
+  # defined?
+  
+  def test_defined?
+    assert( @bind.defined?("a") )
+  end
+  
+  # local variables
+  
+  def test_loacal_variables
+    assert_equal( ["a","b","x"], @bind.local_variables )
+  end
+  
+  def test_brackets
+    assert_equal( "hello", @bind["x"] )
+  end
+  
+  def test_brackets_eq
+    assert_nothing_raised{ @bind["x"] = "goodbye" }
+    assert_equal( "goodbye", @bind["x"] )
+  end
+  
+  # self
+  
+  def test_self
+    assert_equal( self, @bind.self )
+  end
+
+end

data/test/class/tc_class.rb

@@ -0,0 +1,48 @@
+
+require 'test/unit'
+require 'facet/class/cattr'
+
+# fixture
+
+class Tester
+  def initialize
+    @@a = 10
+  end
+  def b
+    @@b
+  end
+end
+
+# testcase
+
+class TC_Class < Test::Unit::TestCase
+  
+  # cattr
+
+  def test_cattr_reader
+    assert_nothing_raised {
+      Tester.class_eval { cattr_reader :a }
+    }
+    t = Tester.new
+    assert_equal( 10, t.a )
+  end
+
+  def test_cattr_writer
+    assert_nothing_raised {
+      Tester.class_eval { cattr_writer :b }
+    }
+    t = Tester.new
+    t.b = 5
+    assert_equal( 5, t.b )
+  end
+  
+  def test_cattr_accessor
+    assert_nothing_raised {
+      Tester.class_eval { cattr_accessor :c }
+    }
+    t = Tester.new
+    t.c = 50
+    assert_equal( 50, t.c )
+  end
+  
+end

data/test/comparable/tc_comparable.rb

@@ -0,0 +1,23 @@
+
+require 'test/unit'
+require 'facet/comparable/bound_by'
+
+
+class TC_Comparable < Test::Unit::TestCase
+  
+  # bound_by
+
+  def test_bound_by
+    assert_equal( 4, 4.bound_by(3,5) )
+    assert_equal( 3, 3.bound_by(3,5) )
+    assert_equal( 5, 5.bound_by(3,5) )
+    assert_equal( 3, 2.bound_by(3,5) )
+    assert_equal( 5, 6.bound_by(3,5) )
+    assert_equal( 'd', 'd'.bound_by('c','e') )
+    assert_equal( 'c', 'c'.bound_by('c','e') )
+    assert_equal( 'e', 'e'.bound_by('c','e') )
+    assert_equal( 'c', 'b'.bound_by('c','e') )
+    assert_equal( 'e', 'f'.bound_by('c','e') )
+  end
+  
+end

data/test/enumerable/tc_enumerable.rb

@@ -0,0 +1,166 @@
+
+require 'test/unit'
+
+require 'facet/enumerable/collect_with_counter'
+require 'facet/enumerable/cross'
+require 'facet/enumerable/each_slice'
+require 'facet/enumerable/every'
+require 'facet/enumerable/graph'
+require 'facet/enumerable/per'
+require 'facet/enumerable/none?'
+require 'facet/enumerable/one?'
+require 'facet/enumerable/partition_by'
+require 'facet/enumerable/to_hash'
+require 'facet/enumerable/uniq_by'
+
+
+class TC_Enumerable < Test::Unit::TestCase
+
+  # collect_with_counter
+  
+  def test_collect_with_counter
+    a = [1,2,3].collect_with_counter{ |e,i| e*i }
+    assert_equal( [0,2,6], a )
+    a = [1,2,3].collect_with_index{ |e,i| e+i }
+    assert_equal( [1,3,5], a )
+  end
+  
+  # cross
+  
+  def test_cross
+    i = [[1,2], [3,4]]
+    o = [[1, 3], [1, 4], [2, 3], [2, 4]]
+    assert_equal( o, Enumerable.cross(*i) )
+    i = [[1,2], [4], ["apple", "banana"]]
+    o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+    assert_equal( o, Enumerable.cross(*i) )
+    a = []
+    [1,2,3].cross([4,5,6]) {|elem| a << elem }
+    assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
+  end
+  
+  # each_slice
+  
+  def test_each_slice
+    x = []
+    [1,2,3,4].each_slice{ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+
+    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 )
+
+    x = []
+    [1,2,3,4].each_slice(2){ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4,5,6,7,8].each_slice(4){ |*a| x << a }
+    o = [[1,2,3,4],[5,6,7,8]]
+    assert_equal( o, x )
+    
+    x = []
+    [1,2,3,4,5,6].each_slice(3){ |*a| x << a }
+    o = [[1,2,3],[4,5,6]]
+    assert_equal( o, x )
+    
+    x = []
+    [1,2,3,4].each_by(2){ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+    
+    x = []
+    [1,2,3,4,5].each_by(3){ |*a| x << a }
+    o = [[1,2,3],[4,5]]
+    assert_equal( o, x )
+    
+    a = [1,2,3,4,5,6]
+    r = []
+    a.each_slice(2){ |x,y| r << [x,y] }
+    assert_equal( [[1,2],[3,4],[5,6]], r )
+    
+    r = []
+    a.each_slice(3){ |*e| r << e }
+    assert_equal( [[1,2,3],[4,5,6]], r )
+  
+  end
+  
+  # every
+  
+  def test_every
+    a = [1,2,3]
+    b = [4,5]
+    assert_equal( [4,5,6], a.every + 3 )
+    assert_equal( [5,7], a.per + b )
+    assert_equal( [2,4,6], a.% + a )
+    assert_equal( [[5,7],[3,4,5]], a.%.+(b,2) )
+    assert_equal( [[5,7],[4,5,6]], a.%.+(b,3) )
+  end
+  
+  # graph
+  
+  def test_graph
+    numbers  = (1..3)
+    squares  = numbers.graph{ |n| [n, n*n] }   
+    assert_equal( {1=>1, 2=>4, 3=>9}, squares )
+    sq_roots = numbers.graph{ |n| [n*n, n] }
+    assert_equal( {1=>1, 4=>2, 9=>3}, sq_roots )
+  end
+
+  # none?
+  
+  def test_none?
+    a = [nil, nil]
+    assert( a.none? )
+    a = [false, false]
+    assert( a.none? )
+    a = [true, false]
+    assert( ! a.none? )
+    a = [nil, 1]
+    assert( ! a.none? )
+  end
+  
+  # one?
+  
+  def test_one?
+    a = [nil, true]
+    assert( a.one? )
+    a = [true, false]
+    assert( a.one? )
+    a = [true, true]
+    assert( ! a.one? )
+    a = [true, 1]
+    assert( ! a.one? )
+    a = [1, 1]
+    assert( ! a.one? )
+  end
+  
+  # partition_by
+  
+  def partition_by
+    x = (1..5).partition_by{ |n| n % 3 }
+    o = { 0 => [3], 1 => [1, 4], 2 => [2,5] }
+    assert_equal( o, x )
+    x = ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
+    o = { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
+    assert_equal( o, x )
+  end
+
+  # to_hash
+    
+  def test_to_hash
+    a = [:a,:b,:c]
+    assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_hash )
+  end
+
+  # uniq_by
+  def test_uniq_by
+    a = [-5, -4, -3, -2, -1, 0]
+    r = (-5..5).to_a.uniq_by{|i| i*i }
+    assert_equal( a, r )
+  end
+  
+end