facets 1.2.0 → 1.2.1

data/test/lib/facets/more/test_dictionary.rb

@@ -0,0 +1,97 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facets/more/dictionary.rb
+#
+# Extracted Fri Mar 24 23:42:50 UTC 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facets/more/dictionary.rb'
+
+
+  require 'test/unit'
+
+  class TC_Dictionary < Test::Unit::TestCase
+
+    def test_create
+      hsh = Dictionary['z', 1, 'a', 2, 'c', 3] 
+      assert_equal( ['z','a','c'], hsh.keys )
+    end
+
+    def test_op_store
+      hsh = Dictionary.new
+      hsh['z'] = 1
+      hsh['a'] = 2
+      hsh['c'] = 3
+      assert_equal( ['z','a','c'], hsh.keys )
+    end
+
+    def test_push
+      hsh = Dictionary['a', 1, 'c', 2, 'z', 3]
+      assert( hsh.push('end', 15) )
+      assert_equal( 15, hsh['end'] )
+      assert( ! hsh.push('end', 30) )
+      assert( hsh.unshift('begin', 50) )
+      assert_equal( 50, hsh['begin'] )
+      assert( ! hsh.unshift('begin', 60) )
+      assert_equal( ["begin", "a", "c", "z", "end"], hsh.keys )
+      assert_equal( ["end", 15], hsh.pop )
+      assert_equal( ["begin", "a", "c", "z"], hsh.keys )
+      assert_equal( ["begin", 50], hsh.shift )
+    end
+
+    def test_insert
+      # front
+      h = Dictionary['a', 1, 'b', 2, 'c', 3]
+      r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
+      assert_equal( 4, h.insert(0,'d',4) )
+      assert_equal( r, h )
+      # back
+      h = Dictionary['a', 1, 'b', 2, 'c', 3]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( 4, h.insert(-1,'d',4) )
+      assert_equal( r, h )
+    end
+
+    def test_update
+      # with other orderred hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = Dictionary['d', 4]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.update(h2) )
+      assert_equal( r, h1 )
+      # with other hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = { 'd' => 4 }
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.update(h2) )
+      assert_equal( r, h1 )
+    end
+
+    def test_merge
+      # with other orderred hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = Dictionary['d', 4]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.merge(h2) )
+      # with other hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = { 'd' => 4 }
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.merge(h2) )
+    end
+
+    def test_order_by
+      h1 = Dictionary['a', 3, 'b', 2, 'c', 1]
+      h1.order_by{ |k,v| v }
+      assert_equal( [1,2,3], h1.values )
+      assert_equal( ['c','b','a'], h1.keys )
+    end
+
+  end
+
+

data/test/lib/facets/more/test_enumerablepass.rb

@@ -0,0 +1,86 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facets/more/enumerablepass.rb
+#
+# Extracted Fri Mar 24 23:42:50 UTC 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facets/more/enumerablepass.rb'
+
+
+  require 'test/unit'
+
+  # fixture
+
+  class PlusArray
+    include EnumerablePass
+    def initialize(arr)
+      @arr = arr
+    end
+    def each(n=0)
+      @arr.each{ |e| yield(e+n) }
+    end
+  end
+
+  class TC_Enumerable < Test::Unit::TestCase
+
+    def test_collect
+      t = PlusArray.new([1,2,3])
+      assert_equal( [5,6,7], t.collect(4){ |e| e } )
+    end
+
+    #def test_each_slice
+    #  t = PlusArray.new([1,2,3,4])
+    #  a = []
+    #  t.each_slice(2,4){ |e,f| a << [e,f] }
+    #  assert_equal( [[5,6],[7,8]], a )
+    #end
+
+    #def test_find
+    #  t = PlusArray.new([1,2,3,4])
+    #  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
+    #  assert_equal(:NOPE, f)
+    #end
+
+    def test_grep
+      # TODO
+    end
+
+    def test_to_a
+      t = PlusArray.new([1,2,3])
+      assert_equal( [5,6,7], t.to_a(4) )  
+    end
+
+    def test_min
+      t = PlusArray.new([1,2,3])
+      assert_equal( 5, t.min(4) )
+    end
+
+    def test_max
+      t = PlusArray.new([1,2,3])
+      assert_equal( 7, t.max(4) )
+    end
+
+    def test_include?
+      t = PlusArray.new([1,2,3])
+      assert( t.include?(7,4) )
+    end
+
+    def test_select
+      t = PlusArray.new([1,2,3])
+      assert_equal( [6], t.select(4){ |x| x == 6 } )
+    end
+
+    def test_reject
+      t = PlusArray.new([1,2,3])
+      assert_equal( [5,7], t.reject(4){ |x| x == 6 } )
+    end
+
+  end
+
+

data/test/lib/facets/more/test_floatstring.rb

@@ -0,0 +1,36 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facets/more/floatstring.rb
+#
+# Extracted Fri Mar 24 23:42:50 UTC 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facets/more/floatstring.rb'
+
+
+  require 'test/unit' 
+
+  class TC_FloatString < Test::Unit::TestCase
+
+    def test_inner_inset
+      fs = FloatString.new( "Hello World!" )
+      fs.inner_insert("XXX", 4)
+      assert_equal("HellXXXo World!", fs.to_s)
+      fs.inner_insert("YYY", 4)
+      assert_equal("HellXXXYYYo World!", fs.to_s)
+    end
+
+    def test_fill
+      fs = FloatString.new( "Hello World!" )
+      fs.inner_insert("XXX", 4)
+      assert_equal("HeNNNN World!", fs.fill("N", 2..4))
+    end
+
+  end
+
+

data/test/lib/facets/more/test_functor.rb

@@ -0,0 +1,39 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facets/more/functor.rb
+#
+# Extracted Fri Mar 24 23:42:50 UTC 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facets/more/functor.rb'
+
+
+  require 'test/unit'
+
+  class TC_Functor < Test::Unit::TestCase
+
+    def test_function
+      f = Functor.new { |op, x| x.send(op, x) }
+      assert_equal( 2, f + 1 ) #=> 2
+      assert_equal( 4, f + 2 ) #=> 4
+      assert_equal( 6, f + 3 ) #=> 6
+      assert_equal( 1, f * 1 ) #=> 1
+      assert_equal( 4, f * 2 ) #=> 4
+      assert_equal( 9, f * 3 ) #=> 9
+    end
+
+    def test_decoration
+      f = Functor.new("A") { |op, a, x| x.send(op, a + x) }
+      assert_equal( 'BAB', f + 'B' )
+      assert_equal( 'CAC', f + 'C' )
+      assert_equal( 'DAD', f + 'D' )
+    end
+
+  end
+
+

data/test/lib/facets/more/test_inheritor.rb

@@ -0,0 +1,155 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facets/more/inheritor.rb
+#
+# Extracted Fri Mar 24 23:42:50 UTC 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facets/more/inheritor.rb'
+
+
+  require 'test/unit'
+
+  #class TC01 < Test::Unit::TestCase
+  #  def setup
+  #    @a = [1]
+  #    @i = Inheritor.new( @a, [2], :+ )
+  #  end
+  #  def test_01_001
+  #    assert_equal([2],@i)
+  #  end
+  #  def test_01_002
+  #    assert_equal([1,2],@i.inheritance)
+  #  end
+  #end
+
+  class TC02 < Test::Unit::TestCase
+    class C
+      inheritor :koko, [1], :+
+    end
+    class D < C
+      inheritor :koko, [2], :+
+    end
+
+    def test_02_001
+      assert_equal( [1], C.koko! )
+    end
+    def test_02_002
+      assert_equal( [1], C.koko )
+    end
+    def test_02_003
+      assert_equal( [2], D.koko! )
+    end
+    def test_02_004
+      assert_equal( [1,2], D.koko )
+    end
+  end
+
+  class TC03 < Test::Unit::TestCase
+    class C
+      inheritor :koko, [1], :+
+    end
+    class D < C
+    end
+
+    def test_03_001
+      assert_equal( [1], C.koko! )
+    end
+    def test_03_002
+      assert_equal( [1], C.koko )
+    end
+    def test_03_003
+      assert_equal( [], D.koko! )
+    end
+    def test_03_004
+      assert_equal( [1], D.koko )
+    end
+  end
+
+  class TC04 < Test::Unit::TestCase
+    class X
+      inheritor :x, {:a=>1}, :merge
+    end
+    module M
+      inheritor :x, {:b=>2}, :merge
+    end
+    class Y < X
+      include M
+      inheritor :x, {:c=>3}, :merge
+    end
+
+    def test_04_001
+      assert_equal( {:a=>1}, X.x )
+    end
+    def test_04_002
+      assert_equal( 2, M.x[:b] )
+    end
+    def test_04_003
+      assert_equal( {:a=>1,:b=>2,:c=>3}, Y.x )
+    end
+    def test_04_004
+      assert_equal( 1, X.x[:a] )
+      assert_equal( nil, X.x[:b] )
+      assert_equal( nil, X.x[:c] )
+    end
+    def test_04_005 ; assert_equal( 1, Y.x[:a] ) ; end
+    def test_04_006 ; assert_equal( 2, Y.x[:b] ) ; end
+    def test_04_007 ; assert_equal( 3, Y.x[:c] ) ; end
+    def test_04_008
+      Y.x![:d] = 4
+      assert_equal( 4, Y.x[:d] )
+    end
+  end
+
+  class TC05 < Test::Unit::TestCase
+    class C
+      inheritor :relations, [], :concat
+    end
+    class D < C
+      #inheritor :relations, [], :concat
+    end
+
+    C.relations! << 1
+    C.relations! << 2
+    D.relations! << 3
+
+    def test_05_001
+      assert_equal( [1,2], C.relations )
+      assert_equal( [1,2,3], D.relations )
+    end
+  end
+
+  class TC06 < Test::Unit::TestCase
+    module MM
+      inheritor :koko, [], :+
+      koko! << 1
+    end
+    class CC1
+      include MM
+      #inheritor :koko, [], :+
+      koko! << 2
+      koko! << 3
+    end
+    class CC2
+      include MM
+      #inheritor :koko, [], :+
+      koko! << 4
+    end
+
+    def test_06_001
+      assert_equal( [1], MM.koko )
+    end
+    def test_06_002
+      assert_equal( [1,2,3], CC1.koko )
+    end
+    def test_06_003
+      assert_equal( [1,4], CC2.koko )
+    end
+  end
+
+

data/test/lib/facets/more/test_interval.rb

@@ -0,0 +1,119 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# for lib/facets/more/interval.rb
+#
+# Extracted Fri Mar 24 23:42:50 UTC 2006
+# Unit Tools Reap Test Extractor
+#
+
+require 'facets/more/interval.rb'
+
+
+  require 'test/unit'
+
+  class InclusiveTest < Test::Unit::TestCase
+
+    def setup
+      @a = Interval.new( 1, 10 )
+      @b = Interval.new( 1, 10, true, false )
+      @c = Interval.new( 1, 10, false, true )
+      @d = Interval.new( 1, 10, true, true )
+    end
+
+    def test_001A ; assert_equal( false, @a.include?(0)  ) ; end
+    def test_002A ; assert_equal( true,  @a.include?(1)  ) ; end
+    def test_003A ; assert_equal( true,  @a.include?(2)  ) ; end
+    def test_004A ; assert_equal( true,  @a.include?(9)  ) ; end
+    def test_005A ; assert_equal( true,  @a.include?(10) ) ; end
+    def test_006A ; assert_equal( false, @a.include?(11) ) ; end
+
+    def test_001B ; assert_equal( false, @b.include?(0)  ) ; end
+    def test_002B ; assert_equal( false, @b.include?(1)  ) ; end
+    def test_003B ; assert_equal( true,  @b.include?(2)  ) ; end
+    def test_004B ; assert_equal( true,  @b.include?(9)  ) ; end
+    def test_005B ; assert_equal( true,  @b.include?(10) ) ; end
+    def test_006B ; assert_equal( false, @b.include?(11) ) ; end
+
+    def test_001C ; assert_equal( false, @c.include?(0)  ) ; end
+    def test_002C ; assert_equal( true,  @c.include?(1)  ) ; end
+    def test_003C ; assert_equal( true,  @c.include?(2)  ) ; end
+    def test_004C ; assert_equal( true,  @c.include?(9)  ) ; end
+    def test_005C ; assert_equal( false, @c.include?(10) ) ; end
+    def test_006C ; assert_equal( false, @c.include?(11) ) ; end
+
+    def test_001D ; assert_equal( false, @d.include?(0)  ) ; end
+    def test_002D ; assert_equal( false, @d.include?(1)  ) ; end
+    def test_003D ; assert_equal( true,  @d.include?(2)  ) ; end
+    def test_004D ; assert_equal( true,  @d.include?(9)  ) ; end
+    def test_005D ; assert_equal( false, @d.include?(10) ) ; end
+    def test_006D ; assert_equal( false, @d.include?(11) ) ; end
+
+  end
+
+  class LrgNumericTest < Test::Unit::TestCase
+
+    def setup
+      @a = Interval.new(0,100000000)
+      @b = Interval.new(0,100000000)
+    end
+
+    def test_001A ; assert_equal( true,  @a.include?(0)         ) ; end
+    def test_002A ; assert_equal( true,  @a.include?(1000)      ) ; end
+    def test_003A ; assert_equal( true,  @a.include?(1000000)   ) ; end
+    def test_004A ; assert_equal( true,  @a.include?(100000000) ) ; end
+    #def test_005A ; assert_equal( false, @a.include?(INFINITY)  ) ; end
+
+    def test_001B ; assert_equal( true,  @b.include?(0)         ) ; end
+    def test_002B ; assert_equal( true,  @b.include?(5)         ) ; end
+    def test_002B ; assert_equal( true,  @b.include?(70007)     ) ; end
+    def test_002B ; assert_equal( true,  @b.include?(5000005)   ) ; end
+    #def test_002B ; assert_equal( false, @b.include?(INFINITY)  ) ; end
+
+  end
+
+  class SelectTest < Test::Unit::TestCase
+
+    def setup
+      @a = Interval.new( 0,10 )
+    end
+
+    def test_001
+      b = @a.collect( 2 ){ |n| n }
+      assert_equal( [0,2,4,6,8,10], b )
+    end
+
+    def test_002
+      b = @a.select{ |n| n % 2 == 0 }
+      assert_equal( [0,2,4,6,8,10], b )
+    end
+
+    def test_003
+      b = @a.collect( 1,2 ){ |n| n }
+      assert_equal( [0,5,10], b )
+    end
+
+    def test_004
+      b = @a.select( 1,2 ){ |n| n % 2 == 0 }
+      assert_equal( [0,10], b )
+    end
+
+  end
+
+  class ArrayTest < Test::Unit::TestCase
+
+    def setup
+      @a = Interval.new( 0,10 ) 
+      @b = Interval.new( 0,1 ) 
+    end
+
+    def test_001A ; assert_equal( [0,5,10], @a.to_a(1,2) ) ; end
+
+    def test_001B ; assert_equal( [0, 0.25, 0.5, 0.75, 1.0], @b.to_a(1,4) ) ; end
+
+  end
+
+