facets 2.2.1 → 2.3.0

data/task/test/whole

@@ -1,34 +0,0 @@
-#!/usr/bin/env ratch
-
-# Run unit tests
-
-puts "Ruby Version: #{RUBY_VERSION}"
-
-live = commandline.flag?('--live')
-
-unless live
-  $LOAD_PATH.unshift(File.expand_path('lib/methods'))
-  $LOAD_PATH.unshift(File.expand_path('lib/core'))
-  $LOAD_PATH.unshift(File.expand_path('lib/more'))
-end
-
-main :test do
-  if find = commandline[0]
-    unless file?(find)
-      find = File.join(find, '**', 'test_*.rb')
-    end
-  else
-    find = 'test/**/test_*.rb'
-  end
-
-  Dir.glob(find).each do |file|
-    next if dir?(file)
-    begin
-      puts "Loading: #{file}" if $DEBUG
-      load(file)
-    rescue LoadError
-      puts "Error loading: #{file}"
-    end
-  end
-end
-

data/test/unit/hash/test_collate.rb

@@ -1,31 +0,0 @@
-require 'test/unit'
-
-class TestHashCollation < Test::Unit::TestCase
-
-    def setup
-      @a = { :a=>1, :b=>2, :z=>26, :all=>%w|a b z|, :stuff1=>%w|foo bar|, :whee=>%w|a b| }
-      @b = { :a=>1, :b=>4, :c=>9,  :all=>%w|a b c|, :stuff2=>%w|jim jam|, :whee=>%w|a b| }
-      @c = { :a=>1, :b=>8, :c=>27 }
-    end
-
-    def test_defaults
-      collated = @a.collate(@b)
-      assert_equal( 8, collated.keys.length, "There are 7 unique keys" )
-      assert_equal( [1,1], collated[ :a ] )
-      assert_equal( [2,4], collated[ :b ] )
-      assert_equal( [9],   collated[ :c ] )
-      assert_equal( [26],  collated[ :z ] )
-      assert_equal( %w|a b z a b c|,  collated[ :all ], "Arrays are merged by default." )
-      assert_equal( %w|foo bar|,  collated[ :stuff1 ] )
-      assert_equal( %w|jim jam|,  collated[ :stuff2 ] )
-      assert_equal( %w|a b a b|,  collated[ :whee ] )
-    end
-
-    def test_multi_collate
-      collated = @a.collate(@b).collate(@c)
-      assert_equal( [1,1,1], collated[ :a ] )
-      assert_equal( [2,4,8], collated[ :b ] )
-      assert_equal( [9,27],  collated[ :c ] )
-    end
-
-  end

data/test/unit/test_random.rb

@@ -1,149 +0,0 @@
-# Test for lib/facets/random.rb
-
-require 'facets/random.rb'
-
-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
-
-
-