facets 2.2.1 → 2.3.0

data/lib/more/facets/instantise.rb

@@ -83,44 +83,3 @@ end
 # Old name. To be deprecated.
 PromoteSelf = Instantise
 
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  # fixture
-
-  module MyModule
-    extend Instantise
-    def self.jumble( obj, arg )
-      obj + arg
-    end
-  end
-
-  class String
-    include MyModule
-  end
-
-  # test
-
-  class TC_PromoteSelf < Test::Unit::TestCase
-
-    def test01
-      assert_equal( 'TryMe', MyModule.jumble( "Try", "Me" ) )
-    end
-
-    def test02
-      assert_equal( 'TryMe', "Try".jumble( "Me" ) )
-    end
-
-  end
-
-=end

data/lib/more/facets/let.rb

@@ -27,7 +27,6 @@
 
 require 'facets/functor'
 
-#
 class Module
 
   # Use let to build a class like so:
@@ -70,22 +69,3 @@ class Module
 end
 
 
-=begin test
-
-  require 'test/unit'
-
-  class TCthis < Test::Unit::TestCase
-
-    class Foo
-      this.bar = 10
-    end
-
-    def test01
-      x = Foo.new
-      assert_equal( 10, x.bar )
-    end
-
-  end
-
-=end
-

data/lib/more/facets/memoize.rb

@@ -108,48 +108,3 @@ module Kernel
 
 end
 
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class T
-    def initialize(a)
-      @a = a
-    end
-    def a
-      "#{@a ^ 3 + 4}"
-    end
-    memoize :a
-  end
-
-  # test
-
-  class TC_Memoize < Test::Unit::TestCase
-
-    def setup
-      @t = T.new(2)
-    end
-
-    def test_memoize_01
-      assert_equal( @t.a, @t.a )
-    end
-
-    def test_memoize_02
-      assert_equal( @t.a.__id__, @t.a.__id__ )
-    end
-
-    def test_memoize_03
-      assert_equal( @t.a.__id__, @t.a.__id__ )
-    end
-
-  end
-
-=end

data/lib/more/facets/multipliers.rb

@@ -97,113 +97,3 @@ class Numeric
 
 end
 
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_Multipliers < Test::Unit::TestCase
-
-    def test_deka
-      assert_equal( 10, 1.deka )
-    end
-
-    def test_hecto
-      assert_equal( 100, 1.hecto )
-    end
-
-    def test_kilo
-      assert_equal( 1000, 1.kilo )
-    end
-
-    def test_mega
-      assert_equal( 1000000, 1.mega )
-    end
-
-    def test_giga
-      assert_equal( 1000000000, 1.giga )
-    end
-
-    def test_tera
-      assert_equal( 1000000000000, 1.tera )
-    end
-
-    def test_peta
-      assert_equal( 1000000000000000, 1.peta )
-    end
-
-    def test_exa
-      assert_equal( 1000000000000000000, 1.exa )
-    end
-
-    # Fractional
-
-    def test_deci
-      assert_equal( 0.1, 1.deci )
-    end
-
-    def test_centi
-      assert_equal( 0.01, 1.centi )
-    end
-
-    def test_milli
-      assert_equal( 0.001, 1.milli )
-    end
-
-    def test_milli
-      assert_equal( 0.000001, 1.micro )
-    end
-
-    def test_nano
-      assert_equal( 0.000000001, 1.nano )
-    end
-
-    def test_pico
-      assert_equal( 0.000000000001, 1.pico )
-    end
-
-    def test_femto
-      assert_equal( 0.000000000000001, 1.femto )
-    end
-
-    def test_atto
-      assert_equal( 0.000000000000000001, 1.atto )
-    end
-
-    # SI Binary
-
-    def test_kibi
-      assert_equal( 1024, 1.kibi )
-    end
-
-    def test_mebi
-      assert_equal( 1024**2, 1.mebi )
-    end
-
-    def test_gibi
-      assert_equal( 1024**3, 1.gibi )
-    end
-
-    def test_tebi
-      assert_equal( 1024**4, 1.tebi )
-    end
-
-    def test_pebi
-      assert_equal( 1024**5, 1.pebi )
-    end
-
-    def test_exbi
-      assert_equal( 1024**6, 1.exbi )
-    end
-
-  end
-
-=end

data/lib/more/facets/ostruct.rb

@@ -224,127 +224,3 @@ class Hash
 
 end
 
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestOpenStruct < Test::Unit::TestCase
-
-    def setup
-      @o = OpenStruct.new(:q => 1)
-    end
-
-    def test_update
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      assert_nothing_raised { o.__update__( h ) }
-      assert_equal( 2, o.b )
-    end
-
-    def test_merge_1
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      q = o.__merge__( h )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
-
-    def test_merge_2
-      o1 = OpenStruct.new( { :a => 1 } )
-      o2 = OpenStruct.new( { :b => 2 } )
-      q = o1.__merge__( o2 )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
-
-    def test_store
-      @o.instance_delegate.store(:a,1)
-      assert_equal( 1, @o.a )
-    end
-
-    def test_update
-      @o.instance_delegate.update(:a=>1)
-      assert_equal( 1, @o.a )
-    end
-
-    def test_op_fetch
-      o = OpenStruct.new( { :a => 1 } )
-      assert_equal( 1, o[:a] )
-    end
-
-    def test_op_store
-      o = OpenStruct.new( { :a => 1 } )
-      assert_nothing_raised { o[:b] = 2 }
-      assert_equal( 2, o.b )
-    end
-
-    def test_update
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      assert_nothing_raised { o.__update__( h ) }
-      assert_equal( 2, o.b )
-    end
-
-    def test_merge_1
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      q = o.__merge__( h )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
-
-    def test_merge_2
-      o1 = OpenStruct.new( { :a => 1 } )
-      o2 = OpenStruct.new( { :b => 2 } )
-      q = o1.__merge__( o2 )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
-
-  end
-
-
-  class TestHashToOpenStruct < Test::Unit::TestCase
-
-    def test_to_ostruct
-      a = { :a => 1, :b => 2, :c => 3 }
-      ao = a.to_ostruct
-      assert_equal( a[:a], ao.a )
-      assert_equal( a[:b], ao.b )
-      assert_equal( a[:c], ao.c )
-    end
-
-    def test_to_ostruct_recurse
-      a = { :a => 1, :b => 2, :c => { :x => 4 } }
-      ao = a.to_ostruct_recurse
-      assert_equal(  a[:a], ao.a )
-      assert_equal(  a[:b], ao.b )
-      assert_equal(  a[:c][:x], ao.c.x )
-    end
-
-    def test_to_ostruct_recurse_with_recursion
-      a = {}
-      a[:a] = a
-      ao = a.to_ostruct_recurse
-      assert_equal( ao, ao.a )
-    end
-
-    def test_to_ostruct_advanced
-      h = { 'a' => { 'b' => 1 } }
-      o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
-      assert_equal( 1, o.a['b'] )
-      assert( Hash === o.a )
-    end
-
-  end
-
-=end

data/lib/more/facets/random.rb

@@ -371,156 +371,3 @@ class String
 
 end
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestKernelRandom < Test::Unit::TestCase
-
-    def test_maybe
-      assert_nothing_raised { maybe }
-    end
-
-  end
-
-  class TestArrayRandom < Test::Unit::TestCase
-
-    def test_at_rand
-      a = [1,2,3,4,5]
-      20.times{ assert_nothing_raised{ a.at_rand } }
-      20.times{ assert( a.include?( a.at_rand ) ) }
-    end
-
-    def test_at_rand!
-      a = ['a','b','c']
-      assert_equal( 1, a.at_rand!.length )
-      assert_equal( 2, a.length )
-    end
-
-    def test_pick
-      a = ['a','b','c']
-      assert_equal( 3, a.pick(3).length )
-      assert_equal( 3, a.length )
-      a = ['a','b','c']
-      assert_equal( 3, a.pick(4).length )
-      assert_equal( 3, a.length )
-    end
-
-    def test_pick!
-      a = ['a','b','c']
-      assert_equal( 3, a.pick!(3).length )
-      assert_equal( 0, a.length )
-      a = ['a','b','c']
-      assert_equal( 3, a.pick!(4).length )
-      assert_equal( 0, a.length )
-    end
-
-    def test_rand_index
-      10.times {
-        i = [1,2,3].rand_index
-        assert( (0..2).include?(i) )
-      }
-    end
-
-    def test_rand_subset
-      10.times {
-        a = [1,2,3,4].rand_subset
-        assert( a.size <= 4 )
-      }
-    end
-
-    def test_shuffle
-      a = [1,2,3,4,5]
-      b = a.shuffle
-      assert_equal( a, b.sort )
-    end
-
-    def test_shuffle!
-      a = [1,2,3,4,5]
-      b = a.dup
-      b.shuffle!
-      assert_equal( a, b.sort )
-    end
-
-  end
-
-  class TestHashRandom < Test::Unit::TestCase
-
-    def test_rand_key
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { assert( h.keys.include?( h.rand_key ) ) }
-    end
-
-    def test_rand_pair
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { k,v = *h.rand_pair; assert_equal( v, h[k] ) }
-    end
-
-    def test_rand_value
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { assert( h.values.include?( h.rand_value ) ) }
-    end
-
-    def test_shuffle
-      h = {:a=>1, :b=>2, :c=>3 }
-      assert_nothing_raised { h.shuffle }
-    end
-
-    def test_shuffle!
-      h = {:a=>1, :b=>2, :c=>3 }
-      assert_nothing_raised { h.shuffle! }
-    end
-
-  end
-
-  class TestStringRandom < Test::Unit::TestCase
-
-    def test_String_rand_letter
-      100.times { |i| assert( /[a-zA-z]/ =~ String.rand_letter ) }
-    end
-
-    def test_at_rand
-      a = '12345'
-      20.times{ assert_nothing_raised{ a.at_rand } }
-      20.times{ assert( a.include?( a.at_rand ) ) }
-    end
-
-    def test_at_rand!
-      x = 'ab'
-      r = x.at_rand!
-      assert( r == 'a' || r == 'b' )
-      assert( x == 'a' || x == 'b' )
-    end
-
-    def test_rand_index
-      10.times { assert( (0..2).include?( 'abc'.rand_index ) ) }
-    end
-
-    def test_rand_byte
-      s = 'ab'
-      r = s.rand_byte
-      assert( r == 97 || r == 98 )
-    end
-
-    def test_rand_byte
-      s = 'ab'
-      r = s.rand_byte
-      assert( r == 97 || r == 98 )
-      assert( s = 'a' || s = 'b' )
-    end
-
-    def test_shuffle
-      assert_nothing_raised { "abc 123".shuffle }
-      #assert_nothing_raised { "abc 123".shuffle! }
-    end
-
-  end
-
-=end