facets 2.1.3 → 2.2.0

data/test/unit/module/test_include.rb

@@ -1,10 +1,4 @@
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |
-#   |_|\___||___/\__|
-#
-# for facets/module/include.rb
+# Test for facets/module/include.rb
 
 require 'facets/module/include.rb'
 require 'test/unit'
@@ -17,33 +11,6 @@ class TestInclude < Test::Unit::TestCase
 
 end
 
-class TestIncludeAs < Test::Unit::TestCase
-
-  module MockModule
-    def x; "X"; end
-    def y; @y; end
-  end
-
-  class MockObject
-    include_as :mod => MockModule
-
-    def initialize
-      @y = "Y"
-    end
-  end
-
-  def test_01
-    m = MockObject.new
-    assert_equal( "X", m.mod.x )
-  end
-
-  def test_02
-    m = MockObject.new
-    assert_equal( "Y", m.mod.y )
-  end
-
-end
-
 class TestOnInclude < Test::Unit::TestCase
 
   module M
@@ -74,4 +41,3 @@ class TestOnInclude < Test::Unit::TestCase
   end
 
 end
-

data/test/unit/module/test_modify.rb

@@ -1,189 +1,177 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/module/modify.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+# Test for facets/module/modify.rb
 
- require 'facets/module/modify.rb'
+require 'facets/module/modify.rb'
 
+require 'test/unit'
 
+# integrate
 
-  require 'test/unit'
+class TestModuleModifyIntegrate < Test::Unit::TestCase
 
-  # integrate
-
-  class TestModuleModifyIntegrate < Test::Unit::TestCase
-
-    module M
-      def x ; 1 ; end
-    end
-
-    class C
-      integrate M do
-        rename :y, :x
-      end
-    end
+  module M
+    def x ; 1 ; end
+  end
 
-    def test_integrate
-      c = C.new
-      assert_raises( NoMethodError ) { c.x }
-      assert_equal( 1, c.y )
+  class C
+    integrate M do
+      rename :y, :x
     end
+  end
 
+  def test_integrate
+    c = C.new
+    assert_raises( NoMethodError ) { c.x }
+    assert_equal( 1, c.y )
   end
 
-  # revisal
+end
 
-  class TestModuleModifyRevisal < Test::Unit::TestCase
+# revisal
 
-    module M
-      def x ; 1 ; end
-    end
+class TestModuleModifyRevisal < Test::Unit::TestCase
 
-    class C
-      include M.revisal {
-        rename :y, :x
-      }
-    end
+  module M
+    def x ; 1 ; end
+  end
 
-    def test_revisal
-      c = C.new
-      assert_raises( NoMethodError ) { c.x }
-      assert_equal( 1, c.y )
-    end
+  class C
+    include M.revisal {
+      rename :y, :x
+    }
+  end
 
+  def test_revisal
+    c = C.new
+    assert_raises( NoMethodError ) { c.x }
+    assert_equal( 1, c.y )
   end
 
-  # nodef
+end
 
-  class TestModuleModifyNoDef < Test::Unit::TestCase
+# nodef
 
-    def the_undefined_method ; 'not here' ; end
+class TestModuleModifyNoDef < Test::Unit::TestCase
 
-    nodef :the_undefined_method
+  def the_undefined_method ; 'not here' ; end
 
-    def test_nodef
-      assert( ! respond_to?( :the_undefined_method ) )
-    end
+  nodef :the_undefined_method
 
+  def test_nodef
+    assert( ! respond_to?( :the_undefined_method ) )
   end
 
-  # redef
+end
 
-  class TestModuleModifyReDef < Test::Unit::TestCase
+# redef
 
-    # redef_method
+class TestModuleModifyReDef < Test::Unit::TestCase
 
-    def a; "a"; end
+  # redef_method
 
-    redefine_method(:a) { nil }
+  def a; "a"; end
 
-    def test_redefine_method
-      assert_equal( nil, a )
-    end
+  redefine_method(:a) { nil }
 
-    # redef
+  def test_redefine_method
+    assert_equal( nil, a )
+  end
 
-    def b; "b"; end
+  # redef
 
-    redef(:b) { "x" }
+  def b; "b"; end
 
-    def test_redef
-      assert_equal( "x", b )
-    end
+  redef(:b) { "x" }
 
+  def test_redef
+    assert_equal( "x", b )
   end
 
-  # redirect_method
+end
 
-  class TestModuleModifyReDirect < Test::Unit::TestCase
+# redirect_method
 
-    def red1 ; 1 ; end
+class TestModuleModifyReDirect < Test::Unit::TestCase
 
-    redirect_method :red2 => :red1
+  def red1 ; 1 ; end
 
-    def test_redirect
-      assert_equal( 1, red2 )
-    end
+  redirect_method :red2 => :red1
 
-    # redirect
+  def test_redirect
+    assert_equal( 1, red2 )
+  end
 
-    def blue1 ; 1 ; end
+  # redirect
 
-    redirect :blue2 => :blue1
+  def blue1 ; 1 ; end
 
-    def test_redirect
-      assert_equal( 1, blue2 )
-    end
+  redirect :blue2 => :blue1
 
+  def test_redirect
+    assert_equal( 1, blue2 )
   end
 
-  # remove method
+end
 
-  class TestModuleModifyRemove < Test::Unit::TestCase
+# remove method
 
-    def the_removed_method ; 'not here' ; end
+class TestModuleModifyRemove < Test::Unit::TestCase
 
-    remove :the_removed_method
+  def the_removed_method ; 'not here' ; end
 
-    def test_remove
-      assert( ! respond_to?( :the_removed_method ) )
-    end
+  remove :the_removed_method
 
+  def test_remove
+    assert( ! respond_to?( :the_removed_method ) )
   end
 
-  # Rename
+end
 
-  class TestModuleModifyRename < Test::Unit::TestCase
+# Rename
 
-    def a; "A" ; end
+class TestModuleModifyRename < Test::Unit::TestCase
 
-    rename_method :b, :a
+  def a; "A" ; end
 
-    def test_rename_method
-      assert( ! respond_to?( :a ) )
-      assert( respond_to?( :b ) )
-    end
+  rename_method :b, :a
 
-    # rename
+  def test_rename_method
+    assert( ! respond_to?( :a ) )
+    assert( respond_to?( :b ) )
+  end
 
-    def c; "C" ; end
+  # rename
 
-    rename :d, :c
+  def c; "C" ; end
 
-    def test_rename
-      assert( ! respond_to?( :c ) )
-      assert( respond_to?( :d ) )
-    end
+  rename :d, :c
 
+  def test_rename
+    assert( ! respond_to?( :c ) )
+    assert( respond_to?( :d ) )
   end
 
-  # wrap_method
+end
 
-  class TestModuleModifyWrap < Test::Unit::TestCase
+# wrap_method
 
-    def a; "A"; end
+class TestModuleModifyWrap < Test::Unit::TestCase
 
-    wrap_method(:a) { |old| old.call + "B" }
+  def a; "A"; end
 
-    def test_wrap_method
-      assert_equal( "AB", a )
-    end
+  wrap_method(:a) { |old| old.call + "B" }
 
-    # wrap
+  def test_wrap_method
+    assert_equal( "AB", a )
+  end
 
-    def b; "B"; end
+  # wrap
 
-    wrap(:b) { |old| old.call + "C" }
+  def b; "B"; end
 
-    def test_wrap
-      assert_equal( "BC", b )
-    end
+  wrap(:b) { |old| old.call + "C" }
 
+  def test_wrap
+    assert_equal( "BC", b )
   end
+
+end

data/test/unit/module/test_name.rb

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

data/test/unit/numeric/test_round.rb

@@ -1,74 +1,59 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/numeric/round.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+# Test for lib/facets/numeric/round
 
- require 'facets/numeric/round.rb'
+require 'facets/numeric/round.rb'
 
+require 'test/unit'
 
+class TestRound < Test::Unit::TestCase
 
-  require 'test/unit'
-
-  class TestRound < Test::Unit::TestCase
-
-    def setup
-      @f0 = [ 0, 10, 15, 105 ]
-      @f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
-    end
-
-    def test_round_at_arg1
-      fr = @f0.collect{ |f| f.round_at(1) }
-      assert_equal( [0,10,15,105], fr )
-      fr = @f1.collect { |f| f.round_at(1) }
-      assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
-    end
-
-    def test_round_at_arg2
-      fr = @f0.collect { |f| f.round_at(2) }
-      assert_equal( [0,10,15,105], fr )
-      fr = @f1.collect { |f| f.round_at(2) }
-      assert_equal( [10.1,10.01,10.9,10.09,10.5,10.05,10.49], fr )
-    end
-
-    def test_round_off
-      assert_equal( 1.0, 1.2.round_off )
-      assert_equal( 2.0, 1.8.round_off )
-    end
+  def setup
+    @f0 = [ 0, 10, 15, 105 ]
+    @f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+  end
 
-    def test_round_to_arg1
-      fr = @f0.collect { |f| f.round_to(0.1) }
-      assert_equal( [0,10,15,105], fr )
-      fr = @f1.collect { |f| f.round_to(0.1) }
-      assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
-    end
+  def test_round_at_arg1
+    fr = @f0.collect{ |f| f.round_at(1) }
+    assert_equal( [0,10,15,105], fr )
+    fr = @f1.collect { |f| f.round_at(1) }
+    assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+  end
 
-    def test_round_to_arg10
-      fr = @f0.collect { |f| f.round_to(10) }
-      assert_equal( [0,10,20,110], fr )
-      fr = @f1.collect { |f| f.round_to(10) }
-      assert_equal( [10,10,10,10,10,10,10], fr )
-    end
+  def test_round_at_arg2
+    fr = @f0.collect { |f| f.round_at(2) }
+    assert_equal( [0,10,15,105], fr )
+    fr = @f1.collect { |f| f.round_at(2) }
+    assert_equal( [10.1,10.01,10.9,10.09,10.5,10.05,10.49], fr )
+  end
 
-    def test_round_off
-      assert_equal( 1.0, 1.2.round_off )
-      assert_equal( 2.0, 1.8.round_off )
-    end
+  def test_round_off
+    assert_equal( 1.0, 1.2.round_off )
+    assert_equal( 2.0, 1.8.round_off )
+  end
 
-    def test_approx?
-      f = 10.006
-      assert( f.approx?(10.01) )
-      assert( f.approx?(10, 0.1) )
-      assert( 100.4.approx?(100.6, 1) )
-    end
+  def test_round_to_arg1
+    fr = @f0.collect { |f| f.round_to(0.1) }
+    assert_equal( [0,10,15,105], fr )
+    fr = @f1.collect { |f| f.round_to(0.1) }
+    assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+  end
 
+  def test_round_to_arg10
+    fr = @f0.collect { |f| f.round_to(10) }
+    assert_equal( [0,10,20,110], fr )
+    fr = @f1.collect { |f| f.round_to(10) }
+    assert_equal( [10,10,10,10,10,10,10], fr )
   end
 
+  def test_round_off
+    assert_equal( 1.0, 1.2.round_off )
+    assert_equal( 2.0, 1.8.round_off )
+  end
 
+  def test_approx?
+    f = 10.006
+    assert( f.approx?(10.01) )
+    assert( f.approx?(10, 0.1) )
+    assert( 100.4.approx?(100.6, 1) )
+  end
 
+end