facets 2.0.2 → 2.0.3

data/test/unit/symbol/test_succ.rb

@@ -1,30 +1,21 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/symbol/succ.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
 
- require 'facets/symbol/succ.rb'
+require 'facets/symbol/succ.rb'
 
+require 'test/unit'
 
+class TestSymbol < Test::Unit::TestCase
 
-  require 'test/unit'
-
-  class TestSymbol < Test::Unit::TestCase
-
-    def test_succ
-      assert_equal( :b, :a.succ )
-      assert_equal( :aab, :aaa.succ )
-      assert_equal( :"2", :"1".succ )
-    end
-
+  def test_succ
+    assert_equal( :b, :a.succ )
+    assert_equal( :aab, :aaa.succ )
+    assert_equal( :"2", :"1".succ )
   end
 
-
+end
 

data/test/unit/symbol/test_to_proc.rb

@@ -0,0 +1,41 @@
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for lib/facets/io/write.rb
+
+require 'facets/symbol/to_proc.rb'
+require 'test/unit'
+
+class TestSymbolToProc < Test::Unit::TestCase
+
+  def test_to_proc
+    x = (1..10).inject(&:*)
+    assert_equal(3628800, x)
+
+    x = %w{foo bar qux}.map(&:reverse)
+    assert_equal(%w{oof rab xuq}, x)
+
+    x = [1, 2, nil, 3, nil].reject(&:nil?)
+    assert_equal([1, 2, 3], x)
+
+    x = %w{ruby and world}.sort_by(&:reverse)
+    assert_equal(%w{world and ruby}, x)
+  end
+
+  def test_to_proc_call
+    assert_instance_of(Proc, up = :upcase.to_proc )
+    assert_equal( "HELLO", up.call("hello") )
+  end
+
+  def test_to_proc_map
+    q = [[1,2,3], [4,5,6], [7,8,9]].map(&:reverse)
+    a = [[3, 2, 1], [6, 5, 4], [9, 8, 7]]
+    assert_equal( a, q )
+  end
+
+end
+
+

data/test/unit/test_association.rb

@@ -1,53 +1,44 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/association.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/association.rb'
-
-
-
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-
-    def setup
-      @complex_hierarchy = [
-        'parent' >> 'child',
-        'childless',
-        'another_parent' >> [
-          'subchildless',
-          'subparent' >> 'subchild'
-        ]
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# facets/association.rb
+
+require 'facets/association.rb'
+
+require 'test/unit'
+
+class TC_Associations < Test::Unit::TestCase
+
+  def setup
+    @complex_hierarchy = [
+      'parent' >> 'child',
+      'childless',
+      'another_parent' >> [
+        'subchildless',
+        'subparent' >> 'subchild'
       ]
-    end
-
-    def test_ohash
-      k,v = [],[]
-      ohash = [ 'A' >> '3', 'B' >> '2', 'C' >> '1' ]
-      ohash.each { |e1,e2| k << e1 ; v << e2 }
-      assert_equal( ['A','B','C'], k )
-      assert_equal( ['3','2','1'], v )
-    end
-
-    def test_complex
-      complex = [ 'Drop Menu' >> [ 'Button 1', 'Button 2', 'Button 3' ], 'Help' ]
-      assert_equal( 'Drop Menu', complex[0].index )
-    end
-
-    def test_associations
-      complex = [ :a >> :b, :a >> :c ]
-      assert_equal( [ :b, :c ], :a.associations )
-    end
+    ]
+  end
 
+  def test_ohash
+    k,v = [],[]
+    ohash = [ 'A' >> '3', 'B' >> '2', 'C' >> '1' ]
+    ohash.each { |e1,e2| k << e1 ; v << e2 }
+    assert_equal( ['A','B','C'], k )
+    assert_equal( ['3','2','1'], v )
   end
 
+  def test_complex
+    complex = [ 'Drop Menu' >> [ 'Button 1', 'Button 2', 'Button 3' ], 'Help' ]
+    assert_equal( 'Drop Menu', complex[0].index )
+  end
 
+  def test_associations
+    complex = [ :a >> :b, :a >> :c ]
+    assert_equal( [ :b, :c ], :a.associations )
+  end
 
+end

data/test/unit/test_attributes.rb

@@ -1,41 +1,32 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/attributes.rb
-  #
-  # Extracted Mon Sep 03 16:23:08 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# facets/attributes.rb
 
- require 'facets/attributes.rb'
+require 'facets/attributes.rb'
 
+require 'test/unit'
 
-
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-    class A
-      attr_accessor :x, :cast=>"to_s"
-    end
-
-    def test_09_001
-      a = A.new
-      assert_equal( [:x], A.attributes )
-    end
+class TC_Attributes_Using_Attr < Test::Unit::TestCase
+  class A
+    attr :x, :cast=>"to_s"
   end
 
-  class TC10 < Test::Unit::TestCase
-    class A
-      attr :x, :cast=>"to_s"
-    end
-
-    def test_10_001
-      assert_equal( "to_s", A.ann(:x,:cast) )
-    end
+  def test_01
+    assert_equal( "to_s", A.ann(:x,:cast) )
   end
+end
 
+class TC_Attributes_Using_Attr_Accessor < Test::Unit::TestCase
+  class A
+    attr_accessor :x, :cast=>"to_s"
+  end
 
-
+  def test_01
+    a = A.new
+    assert_equal( [:x], A.attributes )
+  end
+end

data/test/unit/test_autoarray.rb

@@ -1,34 +1,25 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/autoarray.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/autoarray.rb'
-
-
-
-  require 'test/unit'
-
-  class TC_Autoarray
-
-    def test_001
-      a = Autoarray.new
-      assert_equal( 12, a[1][2][3] = 12 )
-      assert_equal( [nil, [nil, nil, [nil, nil, nil, 12]]], a )
-      assert_equal( [], a[2][3][4] )
-      assert_equal( [nil, [nil, nil, [nil, nil, nil, 12]]], a )
-      assert_equal( "Negative", a[1][-2][1] = "Negative" )
-      assert_equal( [nil, [nil, [nil, "Negative"], [nil, nil, nil, 12]]], a )
-    end
-
+#      _____         _
+#    |_   _|__  ___| |_
+#     | |/ _ \/ __| __|
+#    | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for facets/autoarray.rb
+
+require 'facets/autoarray.rb'
+
+require 'test/unit'
+
+class TC_Autoarray
+
+  def test_001
+    a = Autoarray.new
+    assert_equal( 12, a[1][2][3] = 12 )
+    assert_equal( [nil, [nil, nil, [nil, nil, nil, 12]]], a )
+    assert_equal( [], a[2][3][4] )
+    assert_equal( [nil, [nil, nil, [nil, nil, nil, 12]]], a )
+    assert_equal( "Negative", a[1][-2][1] = "Negative" )
+    assert_equal( [nil, [nil, [nil, "Negative"], [nil, nil, nil, 12]]], a )
   end
 
-
-
+end

data/test/unit/test_command.rb

@@ -258,3 +258,29 @@ class TestCommand < Test::Unit::TestCase
   end
 
 end
+
+
+class TestCommandOptions < Test::Unit::TestCase
+
+  class MyOptions < Command::Options
+    attr_reader :a, :b
+    def a! ; @a = true ; end
+    def b=(x) ; @b = x ; end
+  end
+
+  def test_myoptions1
+    opts = MyOptions.parse("-a -b hi")
+    assert_equal( true, opts.a)
+  end
+
+  def test_myoptions2
+    opts = MyOptions.parse("-a -b hi")
+    assert_equal('hi', opts.b)
+  end
+
+  def test_usage
+    opts = MyOptions.parse("-a -b hi")
+    assert_equal('[-a] [-b value]', opts.usage)
+  end
+
+end

data/test/unit/test_dictionary.rb

@@ -1,122 +1,128 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/dictionary.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/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
-
-    def test_op_store
-      h1 = Dictionary[]
-      h1[:a] = 1
-      h1[:c] = 3
-      assert_equal( [1,3], h1.values )
-      h1[:b,1] = 2
-      assert_equal( [1,2,3], h1.values )
-      assert_equal( [:a,:b,:c], h1.keys )
-    end
-
-    def test_reverse!
-      hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-      hsh.reverse!
-      assert_equal( ['c','a','z'], hsh.keys )
-    end
-
-    def test_enumerable
-      h1 = Dictionary[]
-      h1[:a] = "a"
-      h1[:c] = "b"
-      assert_equal( ["A","B"], h1.collect{|k,v| v.capitalize} )
-    end
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for lib/facets/dictionary.rb
 
+require 'facets/dictionary.rb'
+
+require 'test/unit'
+
+class TC_Dictionary < Test::Unit::TestCase
+
+  def test_create
+    d = Dictionary['z', 1, 'a', 2, 'c', 3]
+    assert_equal( ['z','a','c'], d.keys )
+  end
+
+  def test_op_store
+    d = Dictionary.new
+    d['z'] = 1
+    d['a'] = 2
+    d['c'] = 3
+    assert_equal( ['z','a','c'], d.keys )
+  end
+
+  def test_push
+    d = Dictionary['a', 1, 'c', 2, 'z', 3]
+    assert( d.push('end', 15) )
+    assert_equal( 15, d['end'] )
+    assert( ! d.push('end', 30) )
+    assert( d.unshift('begin', 50) )
+    assert_equal( 50, d['begin'] )
+    assert( ! d.unshift('begin', 60) )
+    assert_equal( ["begin", "a", "c", "z", "end"], d.keys )
+    assert_equal( ["end", 15], d.pop )
+    assert_equal( ["begin", "a", "c", "z"], d.keys )
+    assert_equal( ["begin", 50], d.shift )
+  end
+
+  def test_insert
+    # front
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
+    assert_equal( 4, d.insert(0,'d',4) )
+    assert_equal( r, d )
+    # back
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( 4, d.insert(-1,'d',4) )
+    assert_equal( r, d )
   end
 
+  def test_update
+    # with other orderred hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = Dictionary['d', 4]
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.update(c) )
+    assert_equal( r, d )
+    # with other hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = { 'd' => 4 }
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.update(c) )
+    assert_equal( r, d )
+  end
+
+  def test_merge
+    # with other orderred hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = Dictionary['d', 4]
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.merge(c) )
+    # with other hash
+    d = Dictionary['a', 1, 'b', 2, 'c', 3]
+    c = { 'd' => 4 }
+    r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    assert_equal( r, d.merge(c) )
+  end
 
+  def test_order_by
+    d = Dictionary['a', 3, 'b', 2, 'c', 1]
+    d.order_by{ |k,v| v }
+    assert_equal( [1,2,3], d.values )
+    assert_equal( ['c','b','a'], d.keys )
+  end
+
+  def test_op_store
+    d = Dictionary[]
+    d[:a] = 1
+    d[:c] = 3
+    assert_equal( [1,3], d.values )
+    d[:b,1] = 2
+    assert_equal( [1,2,3], d.values )
+    assert_equal( [:a,:b,:c], d.keys )
+  end
+
+  def test_reverse!
+    d = Dictionary['z', 1, 'a', 2, 'c', 3]
+    d.reverse!
+    assert_equal( ['c','a','z'], d.keys )
+  end
+
+  def test_enumerable
+    d = Dictionary[]
+    d[:a] = "a"
+    d[:c] = "b"
+    assert_equal( ["A","B"], d.collect{|k,v| v.capitalize} )
+  end
+
+  def test_autohash
+    d = Dictionary.new{ |hash,key| hash[key] = 0 }
+    d[:a] = 0
+    d[:b] += 1
+    assert_equal([0, 1], d.values)
+    assert_equal([:a,:b], d.keys)
+  end
+
+  def test_dup_with_array_values
+    d = Dictionary.new
+    d.dup
+    d[:a]=['t',5]
+    assert_equal(d, d.dup)
+  end
+end