facets 2.6.0 → 2.7.0

data/test/more/test_linkedlist.rb

@@ -1,41 +0,0 @@
-# Test facets/linkedlist.rb
-
-require 'facets/linkedlist.rb'
-require 'test/unit'
-
-class TC_LinkedList < Test::Unit::TestCase
-
-  #@cache #?
-
-  def test_all
-    ll = nil
-    assert_nothing_raised('Failed while creating an LinkedList object.') { ll = LinkedList.new }
-    assert_kind_of(LinkedList,ll,'Strangely, the created object does not appear to be an LinkedList.')
-
-    assert_nothing_raised('Failed while pushing a value onto the linked list.') { ll.push 'a' }
-    ll.push 'b'
-    assert_nothing_raised('Failed while assigning a key/value to the linked list.') { ll['c'] = 3 }
-    assert_equal(3,ll.first, 'First element in the linked list appears to be the wrong one.')
-    assert_equal('b',ll.last, 'Last element in the linked list appears to be the wrong one.')
-    assert_nothing_raised('Failed while unshifting a value onto the linked list.') { ll.unshift 'd' }
-    assert_equal('d',ll.first, 'The prior unshift apparently failed.')
-    assert_equal('a',ll['a'], 'Accessing an element by key failed.')
-    assert_equal(4,ll.length, 'The length of the linked list appears to be incorrect.')
-    d = nil
-    assert_nothing_raised('Failed while deleting an element from the middle of the list.') { d = ll.delete('a') }
-    assert_equal('a',d, 'The prior delete returned the wrong value for the deleted object.')
-    assert_equal(3,ll.length, 'The length of the linked list appears to be incorrect following the prior deletion.')
-    assert_nothing_raised('Failed while popping an element from the end of the list.') { d = ll.pop }
-    assert_equal('b',d, 'The prior pop returned the wrong value.')
-    assert_equal(2,ll.length, 'The length of the linked list appears to be incorrect following the prior pop.')
-    assert_equal(['d','c'],ll.queue, 'The queue of keys for the list is incorrect.')
-    assert_equal(['d',3],ll.to_a, 'Converting the list to an array (of values) seems to have failed.')
-    expected = [['c',3],['d','d']]
-    ll.each do |k,v|
-        e = expected.pop
-        assert_equal(e,[k,v], 'While iterates over the list via each(), the value from this iteration is not what was expected.')
-    end
-  end
-
-end
-

data/test/more/test_lrucache.rb

@@ -1,14 +0,0 @@
-# Test lib/facets/lrucache.rb
-#
-# TODO: Need test!!!!!!!
-
-require 'facets/lrucache.rb'
-require 'test/unit'
-
-class TC_LRUCache < Test::Unit::TestCase
-
-  def test_01
-  end
-
-end
-

data/test/more/test_overload.rb

@@ -1,160 +0,0 @@
-# Test facets/overload.rb
-require 'facets/overload.rb'
-require 'test/unit'
-
-#
-#
-class TC_Overload_01 < Test::Unit::TestCase
-
-  class X
-
-    def x
-      "hello"
-    end
-
-    overload :x, Array do |x|
-      [Array, x]
-    end
-
-    overload :x, Symbol do |x|
-      [Symbol, x]
-    end
-
-  end
-
-  def setup
-    @x = X.new
-  end
-
-  def test_x
-    assert_equal( "hello", @x.x )
-  end
-
-  def test_a
-    assert_equal( [Array, [1]], @x.x([1]) )
-  end
-
-  def test_s
-    assert_equal( [Symbol, :a], @x.x(:a) )
-  end
-
-end
-
-#
-#
-class TC_Overload_02 < Test::Unit::TestCase
-
-  class X
-
-    def x
-      "hello"
-    end
-
-    overload :x, Integer do |i|
-      i
-    end
-
-    overload :x, String, String do |s1, s2|
-      [s1, s2]
-    end
-
-  end
-
-  def setup
-    @x = X.new
-  end
-
-  def test_x
-    assert_equal( "hello", @x.x )
-  end
-
-  def test_i
-    assert_equal( 1, @x.x(1) )
-  end
-
-  def test_s
-    assert_equal( ["a","b"], @x.x("a","b") )
-  end
-
-end
-
-#
-#
-class TC_Overload_03 < Test::Unit::TestCase
-
-  class SubArray < Array
-  end
-
-  class SubSubArray < SubArray
-  end
-  
-  
-  class X
-
-    def x
-      "hello"
-    end
-
-    overload :x, Integer do |i|
-      i
-    end
-    
-    overload :x, Symbol do |s|
-      s
-    end
-    
-    overload :x, String, String do |s1, s2|
-      [s1, s2]
-    end
-
-    overload :x, Symbol, String do |s1, s2|
-      [s1, s2]
-    end
-    
-    overload :x, Array do |a|
-      "array"
-    end
-
-  end
-
-  def setup
-    @x = X.new
-  end
-
-  def test_x
-    assert_equal( "hello", @x.x )
-  end
-
-  def test_i
-    assert_equal( 1, @x.x(1) )
-  end
-
-  def test_strings
-    assert_equal( ["a","b"], @x.x("a","b") )
-  end
-
-  def test_symbol_string
-    assert_equal( [:a,"b"], @x.x(:a,"b") )
-  end
-
-  def test_sym
-    assert_equal( :sym, @x.x(:sym) )
-  end
-  
-  def test_subarray
-    assert_equal("array", @x.x([]))
-    assert_equal("array", @x.x(SubArray.new))
-    assert_equal("array", @x.x(SubSubArray.new))
-  end
-  
-  def test_raise
-    assert_raise ArgumentError do
-       X.module_eval do
-        overload :x, 42 do end 
-      end
-    end
-  end
-end
-
-
-

data/test/more/test_paramix.rb

@@ -1,170 +0,0 @@
-require 'facets/paramix.rb'
-require 'test/unit'
-
-class TC_Paramix_01 < Test::Unit::TestCase
-
-  module M
-    include Paramix
-
-    def f
-      mixin_params[M][:p]
-    end
-
-    def self.included(base)
-      params = base.mixin_params[self]
-      base.class_eval do
-        define_method :check do
-          params
-        end
-      end
-    end
-  end
-
-  class C
-    include M[:p => "check"]
-  end
-
-  class D
-    include M[:p => "steak"]
-  end
-
-  def test_01_001
-    c = C.new
-    assert_equal( "check", c.mixin_params[M][:p] )
-    assert_equal( "check", c.f )
-  end
-
-  def test_01_002
-    d = D.new
-    assert_equal( "steak", d.mixin_params[M][:p] )
-    assert_equal( "steak", d.f )
-  end
-
-  def test_01_003
-    assert_equal( {M=>{:p => "check"}}, C.mixin_parameters )
-    assert_equal( {M=>{:p => "steak"}}, D.mixin_parameters )
-  end
-
-  def test_01_004
-    c = C.new
-    assert_equal( {:p => "check"}, c.check )
-    d = D.new
-    assert_equal( {:p => "steak"}, d.check )
-  end
-
-end
-
-class TC_Paramix_02 < Test::Unit::TestCase
-
-  module M
-    # Manually define Paramix method.
-    def self.[](parameters)
-      Paramix.new(self, parameters) do
-        define_method :check do
-          mixin_params[M] # or parameters
-        end
-      end
-    end
-
-    def f
-      mixin_params[M][:p]
-    end
-  end
-
-  class C
-    include M[:p => "check"]
-  end
-
-  class D
-    include M[:p => "steak"]
-  end
-
-  def test_02_001
-    c = C.new
-    assert_equal( "check", c.mixin_params[M][:p] )
-    assert_equal( "check", c.f )
-  end
-
-  def test_02_002
-    d = D.new
-    assert_equal( "steak", d.mixin_params[M][:p] )
-    assert_equal( "steak", d.f )
-  end
-
-  def test_02_003
-    assert_equal( {M=>{:p => "check"}}, C.mixin_parameters )
-    assert_equal( {M=>{:p => "steak"}}, D.mixin_parameters )
-  end
-
-  def test_02_004
-    c = C.new
-    assert_equal( {:p => "check"}, c.check )
-    d = D.new
-    assert_equal( {:p => "steak"}, d.check )
-  end
-
-end
-
-class TC_Paramix_03 < Test::Unit::TestCase
-
-  module M
-    include Paramix
-
-    def f
-      mixin_params[M][:p]
-    end
-  end
-
-  class C
-    extend M[:p => "mosh"]
-  end
-
-  class D
-    extend M[:p => "many"]
-  end
-
-  def test_03_001
-    assert_equal( "mosh", C.f )
-  end
-
-  def test_03_002
-    assert_equal( "many", D.f )
-  end
-
-  def test_03_003
-    assert_equal( {M=>{:p => "mosh"}}, (class << C; self; end).mixin_parameters )
-    assert_equal( {M=>{:p => "many"}}, (class << D; self; end).mixin_parameters )
-  end
-
-end
-
-
-class TC_Paramix_04 < Test::Unit::TestCase
-
-  module O
-    def self.[](parameters)
-      Paramix.new(self, parameters) do
-        attr_accessor mixin_parameters[O][:name]
-      end
-    end
-  end
-
-  class X
-    include O[:name=>"x"]
-  end
-
-  def test_attribute
-    o = X.new
-    assert_nothing_raised{ o.x = 10 }
-    assert_equal(10, o.x)
-  end
-
-  def test_ancestors
-    assert(X.ancestors.include?(X))
-    assert(X.ancestors.include?(O))
-    assert(X.ancestors.include?(Object))
-    assert(X.ancestors.include?(Kernel))
-  end
-
-end
-

data/test/more/test_prototype.rb

@@ -1,35 +0,0 @@
-# Test facets/prototype.rb
-
-require 'facets/prototype.rb'
-
-require 'test/unit'
-
-class TestPrototypeKernel < Test::Unit::TestCase
-
-  def test_new
-    q = nil
-    s = "Testing"
-    assert_nothing_raised { q = s.new }
-    assert_equal( s, q )
-    assert_not_equal( s.object_id, q.object_id )
-  end
-end
-
-class TestPrototype < Test::Unit::TestCase
-
-  def setup
-    @person = prototype do
-      @name = ''
-      @age = 0
-      @announce = fn { |x| "#{x}, #{name} is #{age}" }
-    end
-
-    @person.name = 'Tom'
-    @person.age = 35
-  end
-
-  def test_simple_case
-    assert_equal( "Peter, Tom is 35", @person.announce['Peter'])
-  end
-
-end

data/test/more/test_snapshot.rb

@@ -1,21 +0,0 @@
-# Test lib/facets/snapshot.rb
-
-require 'facets/snapshot.rb'
-require 'test/unit'
-
-class TC_Snapshot < Test::Unit::TestCase
-
-  def setup
-    customer = Struct.new(:name, :address, :zip)
-    joe = customer.new( "Joe Pitare", "1115 Lila Ln.", 47634 )
-    @joe_snap = joe.take_snapshot
-  end
-
-  def test_storage
-    assert_equal( "Joe Pitare", @joe_snap[:name]  )
-    assert_equal( "1115 Lila Ln.", @joe_snap[:address] )
-    assert_equal( 47634, @joe_snap[:zip] )
-  end
-
-end
-

data/test/more/test_sparsearray.rb

@@ -1,279 +0,0 @@
-# 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
-