facets 2.8.4 → 2.9.0.pre.1

data/test/more/test_memoizable.rb

@@ -0,0 +1,38 @@
+covers 'facets/memoizable'
+
+tests Memoizable do
+
+  unit :memoize => "returns expected values" do
+    c = Class.new do
+      include Memoizable
+      def initialize(a)
+        @a = a
+      end
+      attr_accessor :a
+      memoize :a
+    end
+
+    o = c.new("A")
+    o.a.assert == "A"
+    o.a = "B"
+    o.a.assert == "A"
+  end
+
+  unit :memoize => "returns identical objects" do
+    c = Class.new do
+      include Memoizable
+      def initialize(a)
+        @a = a
+      end
+      attr_accessor :a
+      memoize :a
+    end
+
+    o = c.new("A")
+    o.a.__id__.assert == o.a.__id__
+    o.a = "B"
+    o.a.__id__.assert == o.a.__id__
+  end
+
+end
+

data/test/more/test_multipliers.rb

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

data/test/more/test_ostruct.rb

@@ -1,170 +1,168 @@
-# Test facets/ostruct.rb
+covers 'facets/ostruct'
 
-require 'facets/ostruct.rb'
-require 'test/unit'
+tests OpenStruct do
 
-class TestOpenStruct < Test::Unit::TestCase
-
-  def setup
-    @o = OpenStruct.new(:q => 1)
+  unit :__update__ do
+    o = OpenStruct.new(:a => 1)
+    h = { :b => 2 }
+    o.__update__(h)
+    o.b.assert == 2
   end
 
-  def test_update
+  unit :__update__ do
     o = OpenStruct.new( { :a => 1 } )
     h = { :b => 2 }
-    assert_nothing_raised { o.__update__( h ) }
-    assert_equal( 2, o.b )
+    o.__update__(h)
+    o.b.assert == 2
   end
 
-  def test_merge_1
+  unit :__merge__ do
     o = OpenStruct.new( { :a => 1 } )
     h = { :b => 2 }
     q = o.__merge__( h )
-    assert_equal( 1, q.a )
-    assert_equal( 2, q.b )
+    q.a.assert == 1
+    q.b.assert == 2
   end
 
-  def test_merge_2
+  unit :__merge__ do
     o1 = OpenStruct.new( { :a => 1 } )
     o2 = OpenStruct.new( { :b => 2 } )
     q = o1.__merge__( o2 )
-    assert_equal( 1, q.a )
-    assert_equal( 2, q.b )
+    q.a.assert == 1
+    q.b.assert == 2
   end
 
-  def test_store
-    @o.instance_delegate.store(:a,1)
-    assert_equal( 1, @o.a )
+  unit :__merge__ => "with_hash" do
+    o = OpenStruct.new( { :a => 1 } )
+    h = { :b => 2 }
+    q = o.__merge__(h)
+    q.a.assert == 1
+    q.b.assert == 2
   end
 
-  def test_update_using_delegate
-    @o.instance_delegate.update(:a=>1)
-    assert_equal( 1, @o.a )
+  unit :__merge__ => "two openstructs" do
+    o1 = OpenStruct.new( { :a => 1 } )
+    o2 = OpenStruct.new( { :b => 2 } )
+    q = o1.__merge__(o2)
+    q.a.assert == 1
+    q.b.assert == 2
   end
 
-  def test_op_fetch
-    o = OpenStruct.new( { :a => 1 } )
-    assert_equal( 1, o[:a] )
+  unit :instance_delegate => "store" do
+    o = OpenStruct.new(:a => 1)
+    o.instance_delegate.store(:a,1)
+    o.a.assert == 1
   end
 
-  def test_op_store_nothing_raised
-    o = OpenStruct.new( { :a => 1 } )
-    assert_nothing_raised { o[:b] = 2 }
-    assert_equal( 2, o.b )
+  unit :instance_delegate => "update" do
+    o = OpenStruct.new
+    o.instance_delegate.update(:a=>1)
+    o.a.assert == 1
   end
 
-  def test_update_nothing_raised
+  unit :[] do
     o = OpenStruct.new( { :a => 1 } )
-    h = { :b => 2 }
-    assert_nothing_raised { o.__update__( h ) }
-    assert_equal( 2, o.b )
+    o[:a].assert == 1
   end
 
-  def test_merge_with_hash
+  unit :[]= do
     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_two_open_structs
-    o1 = OpenStruct.new( { :a => 1 } )
-    o2 = OpenStruct.new( { :b => 2 } )
-    q = o1.__merge__( o2 )
-    assert_equal( 1, q.a )
-    assert_equal( 2, q.b )
+    o[:b] = 2
+    o.b.assert == 2
   end
 
-end
-
-class TestOpenStructInitialize < Test::Unit::TestCase
-
-  class Person < OpenStruct; end
-
-  def test_1_old_functionality
+  metaunit :new => "old functionality" do
     o = OpenStruct.new
-    assert_nil(o.foo)
+    o.foo.assert.nil?
     o.foo = :bar
-    assert_equal(:bar, o.foo)
+    o.foo.assert ==:bar
     o.delete_field(:foo)
-    assert_nil(o.foo)
+    o.foo.assert.nil?
     o1 = OpenStruct.new(:x => 1, :y => 2)
-    assert_equal(1, o1.x)
-    assert_equal(2, o1.y)
+    o1.x.assert == 1
+    o1.y.assert == 2
     o2 = OpenStruct.new(:x => 1, :y => 2)
-    assert(o1 == o2)
+    o1.assert == o2
   end
 
-  def test_2_new_functionality
+  metaunit :new => "via block" do
     person = OpenStruct.new do |p|
       p.name = 'John Smith'
       p.gender  = :M
       p.age     = 71
     end
-    assert_equal('John Smith', person.name)
-    assert_equal(:M, person.gender)
-    assert_equal(71, person.age)
-    assert_equal(nil, person.address)
+    person.name.assert == 'John Smith'
+    person.gender.assert ==:M
+    person.age.assert == 71
+    person.address.assert ==nil
+  end
+
+  metaunit :new => "via hash and block" do
     person = OpenStruct.new(:gender => :M, :age => 71) do |p|
       p.name = 'John Smith'
     end
-    assert_equal('John Smith', person.name)
-    assert_equal(:M, person.gender)
-    assert_equal(71, person.age)
-    assert_equal(nil, person.address)
+    person.name.assert == 'John Smith'
+    person.gender.assert == :M
+    person.age.assert == 71
+    person.address.assert == nil
   end
 
-  def test_3_subclass
-    person = Person.new do |p|
+  metaunit :new => "subclass via block" do
+    person_class = Class.new(OpenStruct)
+    person = person_class.new do |p|
       p.name = 'John Smith'
       p.gender  = :M
       p.age     = 71
     end
-    assert_equal('John Smith', person.name)
-    assert_equal(:M, person.gender)
-    assert_equal(71, person.age)
-    assert_equal(nil, person.address)
-    person = Person.new(:gender => :M, :age => 71) do |p|
+    person.name.assert == 'John Smith'
+    person.gender.assert == :M
+    person.age.assert == 71
+    person.address.assert == nil
+  end
+
+  metaunit :new => "subclass via hash and block" do
+    person_class = Class.new(OpenStruct)
+    person = person_class.new(:gender => :M, :age => 71) do |p|
       p.name = 'John Smith'
     end
-    assert_equal('John Smith', person.name)
-    assert_equal(:M, person.gender)
-    assert_equal(71, person.age)
-    assert_equal(nil, person.address)
+    person.name.assert == 'John Smith'
+    person.gender.assert == :M
+    person.age.assert == 71
+    person.address.assert ==nil
   end
+
 end
 
-class TestHashToOpenStruct < Test::Unit::TestCase
+tests Hash do
 
-  def test_to_ostruct
+  unit :to_ostruct do
     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 )
+    ao.a.assert == a[:a]
+    ao.b.assert == a[:b]
+    ao.c.assert == a[:c]
   end
 
-  def test_to_ostruct_recurse
+  unit :to_ostruct_recurse do
     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 )
+    ao.a.assert == a[:a]
+    ao.b.assert == a[:b]
+    ao.c.x.assert == a[:c][:x]
   end
 
-  def test_to_ostruct_recurse_with_recursion
+  unit :to_ostruct_recurse => "with recursion" do
     a = {}
     a[:a] = a
     ao = a.to_ostruct_recurse
-    assert_equal( ao, ao.a )
+    ao.a.assert == ao
   end
 
-  def test_to_ostruct_advanced
+  unit :to_ostruct_recurse => "advanced usage" do
     h = { 'a' => { 'b' => 1 } }
     o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
-    assert_equal( 1, o.a['b'] )
-    assert( Hash === o.a )
+    o.a['b'].assert == 1
+    Hash.assert === o.a
   end
 
 end

data/test/more/test_random.rb

@@ -1,176 +1,179 @@
-# Test for facets/random.rb
+covers 'facets/random'
 
-require 'facets/random.rb'
-require 'test/unit'
+tests Random do
 
-class TestKernelRandom < Test::Unit::TestCase
-
-  def test_maybe
-    assert_nothing_raised { maybe }
+  metaunit :letter do
+    100.times { |i| /[a-zA-z]/.assert =~ Random.letter }
   end
 
 end
 
-class TestRangeRandom < Test::Unit::TestCase
-
-  def assert_random_range(range, *msg)
-    assert_nothing_raised{ range.at_rand }
-    assert(range.include?( range.at_rand ), *msg)
-  end
-
-  def test_at_rand_normal
-    20.times do
-      assert_random_range(1..4)
-      assert_random_range(1...4)
-      assert_random_range(1.5..2.5)
-      assert_random_range(1.5...2.5)
-      assert_random_range(-4..-1)
-      assert_random_range(-4...-1)
-      assert_random_range(-2.5..-1.5)
-      assert_random_range(-2.5...-1.5)
-      assert_random_range('a'..'d')
-      assert_random_range('a'...'d')
-      assert_equal(5, (5..5).at_rand)
+tests Range do
+
+  # helper method
+  def assert_at_rand_table(table)
+    table.each do |x, y|
+      20.times do
+        x.at_rand.assert == y
+      end
     end
   end
 
-  def test_at_rand_reverse
-    20.times do
-      assert_equal(nil,(4..1).at_rand)
-      assert_equal(nil,(4...1).at_rand)
-      assert_equal(nil,(-1..-4).at_rand)
-      assert_equal(nil,(-1...-4).at_rand)
-      #assert((1..4).include?((4..1).at_rand))
-      #assert((-4...-1).include?((-1...-4).at_rand))
-      #assert((-4..-1).include?((-1..-4).at_rand))
+  # helper method
+  def assert_random_range(range)
+    20.times do 
+      range.assert.include?( range.at_rand )
     end
   end
 
+  unit :at_rand => "within range" do
+    list = [ 1..4, 1...4, 1.5..2.5, 1.5...2.5, -4..-1, -4...-1,
+             -2.5..-1.5, -2.5...-1.5, 'a'..'d', 'a'...'d' ]
+    list.each{ |rng| assert_random_range(rng) }
+  end
+
+  unit :at_rand => "within range special cases" do
+    assert_at_rand_table(
+      (5..5)       => 5,
+      (5...5)      => nil,
+      (5..-1)      => nil,
+      (5.0..5.0)   => 5.0,
+      (5.0...5.0)  => nil,
+      (5.0...-1.0) => nil
+    )
+  end
+
+  unit :at_rand => "reverse ranges" do
+    assert_at_rand_table(
+      (4..1) => nil,
+      (4...1) => nil,
+      (-1..-4) => nil,
+      (-1...-4) => nil
+    )
+    #assert((1..4).include?((4..1).at_rand))
+    #assert((-4...-1).include?((-1...-4).at_rand))
+    #assert((-4..-1).include?((-1..-4).at_rand))
+  end
+
   # I'd rather it return the first sentinel than +nil+.
   # Really, ruby should be raising an error as an invalid range value.
-  def test_at_rand_exclusive
-    assert_equal(nil,(5...5).at_rand)
-    #assert_raises(RangeError) do
+  unit :at_rand => "exclusive range" do
+    (5...5).at_rand.assert == nil
+    #expect RangeError do
     #  (5...5).at_rand
     #end
   end
 
 end
 
-class TestArrayRandom < Test::Unit::TestCase
+tests Array do
 
-  def test_at_rand
+  unit :at_rand do
     a = [1,2,3,4,5]
-    20.times{ assert_nothing_raised{ a.at_rand } }
-    20.times{ assert( a.include?( a.at_rand ) ) }
+    20.times{ a.assert.include?( a.at_rand ) }
   end
 
-  def test_at_rand!
+  unit :at_rand! do
     a = ['a','b','c']
-    assert_equal( 1, a.at_rand!.length )
-    assert_equal( 2, a.length )
+    a.at_rand!.length.assert == 1
+    a.length.assert == 2
   end
 
-  def test_pick
+  unit :pick do
     a = ['a','b','c']
-    assert_equal( 3, a.pick(3).length )
-    assert_equal( 3, a.length )
+    a.pick(3).length.assert == 3
+    a.length.assert == 3
     a = ['a','b','c']
-    assert_equal( 3, a.pick(4).length )
-    assert_equal( 3, a.length )
+    a.pick(4).length.assert == 3
+    a.length.assert == 3
   end
 
-  def test_pick!
+  unit :pick! do
     a = ['a','b','c']
-    assert_equal( 3, a.pick!(3).length )
-    assert_equal( 0, a.length )
+    a.pick!(3).length.assert == 3
+    a.length.assert == 0
     a = ['a','b','c']
-    assert_equal( 3, a.pick!(4).length )
-    assert_equal( 0, a.length )
+    a.pick!(4).length.assert == 3
+    a.length.assert == 0
   end
 
-  def test_rand_index
+  unit :rand_index do
     10.times {
       i = [1,2,3].rand_index
-      assert( (0..2).include?(i) )
+      (0..2).assert.include?(i)
     }
   end
 
-  def test_rand_subset
+  unit :rand_subset do
     10.times {
       a = [1,2,3,4].rand_subset
-      assert( a.size <= 4 )
+      a.size.assert <= 4
     }
   end
 
-  def test_shuffle
+  unit :shuffle do
     a = [1,2,3,4,5]
     b = a.shuffle
-    assert_equal( a, b.sort )
+    b.sort.assert == a
   end
 
-  def test_shuffle!
+  unit :shuffle! do
     a = [1,2,3,4,5]
     b = a.dup
     b.shuffle!
-    assert_equal( a, b.sort )
+    b.sort.assert == a
   end
 
 end
 
-class TestHashRandom < Test::Unit::TestCase
+tests Hash do
 
-  def test_rand_key
+  unit :rand_key do
     h = { :a=>1, :b=>2, :c=>3 }
-    10.times { assert( h.keys.include?( h.rand_key ) ) }
+    10.times { h.keys.assert.include?( h.rand_key ) }
   end
 
-  def test_rand_pair
+  unit :rand_pair do
     h = { :a=>1, :b=>2, :c=>3 }
-    10.times { k,v = *h.rand_pair; assert_equal( v, h[k] ) }
+    10.times { k,v = *h.rand_pair; h[k].assert == v }
   end
 
-  def test_rand_value
+  unit :rand_value do
     h = { :a=>1, :b=>2, :c=>3 }
-    10.times { assert( h.values.include?( h.rand_value ) ) }
+    10.times { h.values.assert.include?( h.rand_value ) }
   end
 
-  def test_shuffle
+  unit :shuffle do
     h = {:a=>1, :b=>2, :c=>3 }
-    assert_nothing_raised { h.shuffle }
+    h.shuffle
   end
 
-  def test_shuffle!
+  unit :shuffle! do
     h = {:a=>1, :b=>2, :c=>3 }
-    assert_nothing_raised { h.shuffle! }
+    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
+tests String do
 
-  def test_at_rand
+  unit :at_rand do
     a = '12345'
-    20.times{ assert_nothing_raised{ a.at_rand } }
-    20.times{ assert( a.include?( a.at_rand ) ) }
+    20.times{ a.assert.include?( a.at_rand ) }
   end
 
-  def test_at_rand!
+  unit :at_rand! do
     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 ) ) }
+  unit :rand_index do
+    10.times{ (0..2).assert.include?( 'abc'.rand_index ) }
   end
 
-  def test_rand_byte
+  unit :rand_byte do
     2.times do
       s = 'ab'
       r = s.rand_byte
@@ -182,9 +185,13 @@ class TestStringRandom < Test::Unit::TestCase
     end
   end
 
-  def test_shuffle
-    assert_nothing_raised { "abc 123".shuffle }
-    #assert_nothing_raised { "abc 123".shuffle! }
+  unit :shuffle do
+    "abc 123".shuffle
+    #"abc 123".shuffle!
+  end
+
+  unit :shuffle! do
+    "abc 123".shuffle!
   end
 
 end