facets 2.1.2 → 2.1.3

data/test/unit/test_openobject.rb

@@ -1,128 +1,112 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/openobject.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/openobject.rb'
-
-
-
-  require 'test/unit'
-
-  class TestOpenObject1 < Test::Unit::TestCase
-
-    def test_1_01
-      o = OpenObject.new
-      assert( o.respond_to?(:key?) )
-    end
-
-    def test_1_02
-      assert_instance_of( OpenObject, OpenObject[{}] )
-    end
-
-    def test_1_03
-      f0 = OpenObject.new
-      f0[:a] = 1
-      #assert_equal( [1], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-
-    def test_1_04
-      f0 = OpenObject[:a=>1]
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-
-    def test_1_05
-      f0 = OpenObject[:class=>1]
-      assert_equal( 1, f0.class )
-    end
+# Test facets/openobject.rb
+
+require 'facets/openobject.rb'
+require 'test/unit'
+
+class TestOpenObject1 < Test::Unit::TestCase
+
+  def test_1_01
+    o = OpenObject.new
+    assert( o.respond_to?(:key?) )
+  end
+
+  def test_1_02
+    assert_instance_of( OpenObject, OpenObject[{}] )
+  end
+
+  def test_1_03
+    f0 = OpenObject.new
+    f0[:a] = 1
+    #assert_equal( [1], f0.to_a )
+    assert_equal( {:a=>1}, f0.to_h )
   end
 
-  class TestOpenObject2 < Test::Unit::TestCase
-
-    def test_2_01
-      f0 = OpenObject[:f0=>"f0"]
-      h0 = { :h0=>"h0" }
-      assert_equal( OpenObject[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-
-    def test_2_02
-      f1 = OpenObject[:f1=>"f1"]
-      h1 = { :h1=>"h1" }
-      f1.send(:update,h1)
-      h1.update( f1 )
-      assert_equal( OpenObject[:f1=>"f1", :h1=>"h1"], f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-
-    def test_2_03
-      o = OpenObject[:a=>1,:b=>{:x=>9}]
-      assert_equal( 9, o[:b][:x] )
-      assert_equal( 9, o.b[:x] )
-    end
-
-    def test_2_04
-      o = OpenObject["a"=>1,"b"=>{:x=>9}]
-      assert_equal( 1, o["a"] )
-      assert_equal( 1, o[:a] )
-      assert_equal( {:x=>9}, o["b"] )
-      assert_equal( {:x=>9}, o[:b] )
-      assert_equal( 9, o["b"][:x] )
-      assert_equal( nil, o[:b]["x"] )
-    end
+  def test_1_04
+    f0 = OpenObject[:a=>1]
+    f0[:b] = 2
+    assert_equal( {:a=>1,:b=>2}, f0.to_h )
+  end
 
+  def test_1_05
+    f0 = OpenObject[:class=>1]
+    assert_equal( 1, f0.class )
   end
+end
 
-  class TestOpenObject3 < Test::Unit::TestCase
-    def test_3_01
-      fo = OpenObject.new
-      9.times{ |i| fo.send( "n#{i}=", 1 ) }
-      9.times{ |i|
-        assert_equal( 1, fo.send( "n#{i}" ) )
-      }
-    end
+class TestOpenObject2 < Test::Unit::TestCase
+
+  def test_2_01
+    f0 = OpenObject[:f0=>"f0"]
+    h0 = { :h0=>"h0" }
+    assert_equal( OpenObject[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
+    assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
   end
 
-  class TestOpenObject4 < Test::Unit::TestCase
+  def test_2_02
+    f1 = OpenObject[:f1=>"f1"]
+    h1 = { :h1=>"h1" }
+    f1.send(:update,h1)
+    h1.update( f1 )
+    assert_equal( OpenObject[:f1=>"f1", :h1=>"h1"], f1 )
+    assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
+  end
 
-    def test_4_01
-      ho = {}
-      fo = OpenObject.new
-      5.times{ |i| ho["n#{i}".to_sym]=1 }
-      5.times{ |i| fo.send( "n#{i}=", 1 ) }
-      assert_equal(ho, fo.to_h)
-    end
+  def test_2_03
+    o = OpenObject[:a=>1,:b=>{:x=>9}]
+    assert_equal( 9, o[:b][:x] )
+    assert_equal( 9, o.b[:x] )
+  end
 
+  def test_2_04
+    o = OpenObject["a"=>1,"b"=>{:x=>9}]
+    assert_equal( 1, o["a"] )
+    assert_equal( 1, o[:a] )
+    assert_equal( {:x=>9}, o["b"] )
+    assert_equal( {:x=>9}, o[:b] )
+    assert_equal( 9, o["b"][:x] )
+    assert_equal( nil, o[:b]["x"] )
   end
 
-  class TestOpenObject5 < Test::Unit::TestCase
+end
 
-    def test_5_01
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = p.to_openobject
-      assert_equal( "Hello", o.word )
-    end
+class TestOpenObject3 < Test::Unit::TestCase
+  def test_3_01
+    fo = OpenObject.new
+    9.times{ |i| fo.send( "n#{i}=", 1 ) }
+    9.times{ |i|
+      assert_equal( 1, fo.send( "n#{i}" ) )
+    }
+  end
+end
 
-    def test_5_02
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = OpenObject[:a=>1,:b=>2]
-      assert_instance_of( Proc, o.to_proc )
-    end
+class TestOpenObject4 < Test::Unit::TestCase
 
+  def test_4_01
+    ho = {}
+    fo = OpenObject.new
+    5.times{ |i| ho["n#{i}".to_sym]=1 }
+    5.times{ |i| fo.send( "n#{i}=", 1 ) }
+    assert_equal(ho, fo.to_h)
   end
 
+end
 
+class TestOpenObject5 < Test::Unit::TestCase
+
+  def test_5_01
+    p = lambda { |x|
+      x.word = "Hello"
+    }
+    o = p.to_openobject
+    assert_equal( "Hello", o.word )
+  end
+
+  def test_5_02
+    p = lambda { |x|
+      x.word = "Hello"
+    }
+    o = OpenObject[:a=>1,:b=>2]
+    assert_instance_of( Proc, o.to_proc )
+  end
 
+end

data/test/unit/test_ostruct.rb

@@ -1,10 +1,4 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |
-#   |_|\___||___/\__|
-#
-# for lib/facets/ostruct.rb
+# Test facets/ostruct.rb
 
 require 'facets/ostruct.rb'
 require 'test/unit'

data/test/unit/test_overload.rb

@@ -1,9 +1,4 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |
-#   |_|\___||___/\__|
-#
+# Test facets/overload.rb
 
 require 'facets/overload.rb'
 

data/test/unit/test_paramix.rb

@@ -1,10 +1,4 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |
-#   |_|\___||___/\__|
-#
-# for facets/paramix.rb
+# Test facets/paramix.rb
 
 require 'facets/paramix.rb'
 

data/test/unit/test_pp_s.rb

@@ -1,10 +1,4 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |
-#   |_|\___||___/\__|
-#
-# for facets/pp_s.rb
+# Test facets/pp_s.rb
 
 require 'facets/pp_s.rb'
 require 'test/unit'

data/test/unit/test_prototype.rb

@@ -1,9 +1,4 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |
-#   |_|\___||___/\__|
-#
+# Test facets/prototype.rb
 
 require 'facets/prototype.rb'
 

data/test/unit/test_recorder.rb

@@ -1,46 +1,31 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/recorder.rb
-  #
-  # Extracted Mon Sep 03 16:23:08 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+# Test facets/recorder.rb
 
- require 'facets/recorder.rb'
+require 'facets/recorder.rb'
 
+require 'test/unit'
 
+#class Object
+#  def &(o)
+#    self && o
+#  end
+#end
 
-  require 'test/unit'
-
-  #class Object
-  #  def &(o)
-  #    self && o
-  #  end
-  #end
-
-  class TCRecorder < Test::Unit::TestCase
-
-    class Z
-      def name ; 'George' ; end
-      def age ; 12 ; end
-    end
-
-    def setup
-      @z = Z.new
-    end
-
-    def test_001
-      r = Recorder.new
-      q = proc { |x| (x.name == 'George') & (x.age > 10) }
-      x = q[r]
-      assert( x.__call__(@z) )
-    end
+class TCRecorder < Test::Unit::TestCase
 
+  class Z
+    def name ; 'George' ; end
+    def age ; 12 ; end
   end
 
+  def setup
+    @z = Z.new
+  end
 
+  def test_001
+    r = Recorder.new
+    q = proc { |x| (x.name == 'George') & (x.age > 10) }
+    x = q[r]
+    assert( x.__call__(@z) )
+  end
 
+end

data/test/unit/test_snapshot.rb

@@ -1,18 +1,6 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/snapshot.rb
-  #
-  # Extracted Mon Sep 03 16:23:08 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/snapshot.rb'
-
+# Test lib/facets/snapshot.rb
 
+require 'facets/snapshot.rb'
 
 require 'test/unit'
 

data/test/unit/test_stylize.rb

@@ -1,154 +1,140 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/stylize.rb
-  #
-  # Extracted Mon Sep 03 16:23:08 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/stylize.rb'
-
-
-
-  require 'test/unit'
-
-  class TestInflect < Test::Unit::TestCase
-
-    def test_basename_01
-      assert_equal( "Unit", "Test::Unit".basename )
-    end
-
-    def test_basename_02
-      a =  "Down::Bottom"
-      assert_raises( ArgumentError ) { a.basename(1) }
-    end
-
-    def test_basename_03
-      a =  "Down::Bottom"
-      assert_equal( "Bottom", a.basename )
-    end
-
-    def test_basename_04
-      b =  "Further::Down::Bottom"
-      assert_equal( "Bottom", b.basename )
-    end
-
-    def test_camelize
-      assert_equal( 'ThisIsIt', 'this_is_it'.camelize )
-    end
-
-    def test_camelcase
-      assert_equal( "abcXyz", "abc_xyz".camelcase )
-      assert_equal( "abcXyz", "abc xyz".camelcase )
-      assert_equal( "abcXyz", "abc  xyz".camelcase )
-      assert_equal( "abcXyz", "abc\txyz".camelcase )
-      assert_equal( "abcXyz", "abc\nxyz".camelcase )
-      assert_equal( "abcXyz", "abc____xyz".camelcase )
-    end
-
-    def test_camelcase_true
-      assert_equal( "AbcXyz", "abc_xyz".camelcase(true) )
-      assert_equal( "AbcXyz", "abc xyz".camelcase(true) )
-      assert_equal( "AbcXyz", "abc  xyz".camelcase(true) )
-      assert_equal( "AbcXyz", "abc\txyz".camelcase(true) )
-      assert_equal( "AbcXyz", "abc\nxyz".camelcase(true) )
-    end
+# Test lib/facets/stylize.rb
 
-    def test_humanize
-      assert_equal( 'This is it', 'this_is_it'.humanize )
-    end
+require 'facets/stylize.rb'
 
-    def test_title
-      r = "try this out".title
-      x = "Try This Out"
-      assert_equal(x,r)
-    end
+require 'test/unit'
 
-    def test_demodulize_01
-      a =  "Down::Bottom"
-      assert_raises( ArgumentError ) { a.demodulize(1) }
-    end
 
-    def test_demodulize_02
-      a =  "Down::Bottom"
-      assert_equal( "Bottom", a.demodulize )
-    end
+class TestStylize < Test::Unit::TestCase
 
-    def test_demodulize_03
-      b =  "Further::Down::Bottom"
-      assert_equal( "Bottom", b.demodulize )
-    end
+  def test_basename_01
+    assert_equal( "Unit", "Test::Unit".basename )
+  end
 
-    def test_demodulize_01
-      a =  "Down::Bottom"
-      assert_raises( ArgumentError ) { a.demodulize(1) }
-    end
+  def test_basename_02
+    a =  "Down::Bottom"
+    assert_raises( ArgumentError ) { a.basename(1) }
+  end
 
-    def test_demodulize_02
-      a =  "Down::Bottom"
-      assert_equal( "Bottom", a.demodulize )
-    end
+  def test_basename_03
+    a =  "Down::Bottom"
+    assert_equal( "Bottom", a.basename )
+  end
 
-    def test_demodulize_03
-      b =  "Further::Down::Bottom"
-      assert_equal( "Bottom", b.demodulize )
-    end
+  def test_basename_04
+    b =  "Further::Down::Bottom"
+    assert_equal( "Bottom", b.basename )
+  end
 
-    def test_methodize
-      assert_equal( 'hello_world', 'HelloWorld'.methodize )
-      assert_equal( '__unix_path', '/unix_path'.methodize )
-    end
+  def test_camelize
+    assert_equal( 'ThisIsIt', 'this_is_it'.camelize )
+  end
 
-    def test_modulize
-      assert_equal( 'MyModule::MyClass',   'my_module__my_class'.modulize   )
-      assert_equal( '::MyModule::MyClass', '__my_module__my_class'.modulize )
-      assert_equal( 'MyModule::MyClass',   'my_module/my_class'.modulize    )
-      assert_equal( '::MyModule::MyClass', '/my_module/my_class'.modulize   )
-    end
+  def test_camelcase
+    assert_equal( "abcXyz", "abc_xyz".camelcase )
+    assert_equal( "abcXyz", "abc xyz".camelcase )
+    assert_equal( "abcXyz", "abc  xyz".camelcase )
+    assert_equal( "abcXyz", "abc\txyz".camelcase )
+    assert_equal( "abcXyz", "abc\nxyz".camelcase )
+    assert_equal( "abcXyz", "abc____xyz".camelcase )
+  end
 
-    def test_pathize
-      assert_equal( 'my_module/my_class',   'MyModule::MyClass'.pathize )
-      assert_equal( 'u_r_i',                'URI'.pathize )
-      assert_equal( '/my_class',            '::MyClass'.pathize )
-      assert_equal( '/my_module/my_class/', '/my_module/my_class/'.pathize )
-    end
+  def test_camelcase_true
+    assert_equal( "AbcXyz", "abc_xyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc xyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc  xyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc\txyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc\nxyz".camelcase(true) )
+  end
 
+  def test_humanize
+    assert_equal( 'This is it', 'this_is_it'.humanize )
   end
 
+  def test_title
+    r = "try this out".title
+    x = "Try This Out"
+    assert_equal(x,r)
+  end
 
-  class TestClassInflect < Test::Unit::TestCase
+  def test_demodulize_01
+    a =  "Down::Bottom"
+    assert_raises( ArgumentError ) { a.demodulize(1) }
+  end
 
-    def test_method_name
-      assert_equal( Test::Unit::TestCase.methodize, 'test__unit__test_case' )
-    end
+  def test_demodulize_02
+    a =  "Down::Bottom"
+    assert_equal( "Bottom", a.demodulize )
+  end
 
-    def test_method_name
-      assert_equal( Test::Unit::TestCase.pathize, '/test/unit/test_case' )
-    end
+  def test_demodulize_03
+    b =  "Further::Down::Bottom"
+    assert_equal( "Bottom", b.demodulize )
+  end
 
+  def test_demodulize_01
+    a =  "Down::Bottom"
+    assert_raises( ArgumentError ) { a.demodulize(1) }
   end
 
-  class TestIntegerInflect < Test::Unit::TestCase
+  def test_demodulize_02
+    a =  "Down::Bottom"
+    assert_equal( "Bottom", a.demodulize )
+  end
 
-    def test_ordinalize
-      assert_equal( '1st', '1'.ordinalize )
-      assert_equal( '2nd', '2'.ordinalize )
-      assert_equal( '3rd', '3'.ordinalize )
-      assert_equal( '4th', '4'.ordinalize )
-    end
+  def test_demodulize_03
+    b =  "Further::Down::Bottom"
+    assert_equal( "Bottom", b.demodulize )
+  end
 
-    def test_ordinal
-      assert_equal( '1st', 1.ordinal )
-      assert_equal( '2nd', 2.ordinal )
-      assert_equal( '3rd', 3.ordinal )
-      assert_equal( '4th', 4.ordinal )
-    end
+  def test_methodize
+    assert_equal( 'hello_world', 'HelloWorld'.methodize )
+    assert_equal( '__unix_path', '/unix_path'.methodize )
+  end
 
+  def test_modulize
+    assert_equal( 'MyModule::MyClass',   'my_module__my_class'.modulize   )
+    assert_equal( '::MyModule::MyClass', '__my_module__my_class'.modulize )
+    assert_equal( 'MyModule::MyClass',   'my_module/my_class'.modulize    )
+    assert_equal( '::MyModule::MyClass', '/my_module/my_class'.modulize   )
   end
 
+  def test_pathize
+    assert_equal( 'my_module/my_class',   'MyModule::MyClass'.pathize )
+    assert_equal( 'u_r_i',                'URI'.pathize )
+    assert_equal( '/my_class',            '::MyClass'.pathize )
+    assert_equal( '/my_module/my_class/', '/my_module/my_class/'.pathize )
+  end
+
+end
+
+
+class TestClassStylize < Test::Unit::TestCase
 
+  def test_method_name
+    assert_equal( Test::Unit::TestCase.methodize, 'test__unit__test_case' )
+  end
+
+  def test_method_name
+    assert_equal( Test::Unit::TestCase.pathize, '/test/unit/test_case' )
+  end
+
+end
+
+class TestIntegerStylize < Test::Unit::TestCase
+
+  def test_ordinalize
+    assert_equal( '1st', '1'.ordinalize )
+    assert_equal( '2nd', '2'.ordinalize )
+    assert_equal( '3rd', '3'.ordinalize )
+    assert_equal( '4th', '4'.ordinalize )
+  end
+
+  def test_ordinal
+    assert_equal( '1st', 1.ordinal )
+    assert_equal( '2nd', 2.ordinal )
+    assert_equal( '3rd', 3.ordinal )
+    assert_equal( '4th', 4.ordinal )
+  end
 
+end