facets 2.8.4 → 2.9.0.pre.1

data/test/core/kernel/test_require_all.rb

@@ -0,0 +1,11 @@
+covers 'facets/kernel/require_all'
+
+tests Kernel do
+
+  omit unit :require_all do
+  end
+
+  omit unit :load_all do
+  end
+
+end

data/test/core/kernel/test_require_relative.rb

@@ -0,0 +1,12 @@
+covers 'facets/kernel/require_relative'
+covers 'facets/kernel/load_relative'
+
+tests Kernel do
+
+  omit unit :require_relative do
+  end
+
+  omit unit :load_relative do
+  end
+
+end

data/test/core/kernel/test_respond.rb

@@ -0,0 +1,32 @@
+covers 'facets/kernel/respond'
+
+tests Kernel do
+
+  unit :respond do
+    c = Class.new do
+      def f; "f"; end
+    end
+  
+    x = c.new
+    x.respond(:f).assert == "f"
+    x.respond(:g).assert == nil
+
+    x.respond.f.assert == "f"
+    x.respond.g.assert == nil
+  end
+
+  #
+  #unit :respond_with_value do
+  #  c = Class.new do
+  #    def f; "f"; end
+  #  end
+  #
+  #  x = c.new
+  #  x.respond_with_value(:f).assert == "f"
+  #  x.respond_with_value(:g).assert == nil
+  #
+  #  x.respond_with_value.f.assert == "f"
+  #  x.respond_with_value.g.assert == nil
+  #end
+
+end

data/test/core/kernel/test_returning.rb

@@ -1,16 +1,13 @@
-# Test for facets/kernel/returning.rb
+covers 'facets/kernel/returning'
 
-require 'facets/kernel/returning.rb'
-require 'test/unit'
+tests Kernel do
 
-class TC_Kernel < Test::Unit::TestCase
-
-  def test_returning
+  unit :returning do
     foo = returning( values = [] ) do
       values << 'bar'
       values << 'baz'
     end
-    assert_equal( ['bar', 'baz'], foo )
+    foo.assert == ['bar', 'baz']
   end
 
 end

data/test/core/kernel/test_silence.rb

@@ -1,15 +1,24 @@
-# Test for facets/kernel/silence
+covers 'facets/kernel/silence'
 
-require 'facets/kernel/silence.rb'
+tests Kernel do
 
-require 'test/unit'
+  # TODO: figure out how to test silence methods
 
-class TestKernelError < Test::Unit::TestCase
+  context "Not straight foward to test since they effect output."
 
-  def test_silence_warnings
-    silence_warnings do
-      assert( ! $VERBOSE )
-    end
+  omit unit :silence do
+  end
+
+  omit unit :silence_stream do
+  end
+
+  omit unit :silence_stderr do
+  end
+
+  omit unit :silence_stdout do
+  end
+
+  omit unit :silently do
   end
 
 end

data/test/core/kernel/test_singleton_class.rb

@@ -0,0 +1,11 @@
+covers 'facets/kernel/singleton_class'
+
+tests Kernel do
+
+  unit :singleton_class do
+    x = Class.new
+    m = (class << x; self; end)
+    x.singleton_class.assert == m
+  end
+
+end

data/test/core/kernel/test_source_location.rb

@@ -0,0 +1,18 @@
+covers 'facets/kernel/source_location'
+
+tests Kernel do
+
+  # TODO: lemon seems to intefer with call stack
+
+  omit unit :source_location do
+    file, line, meth = source_location_example
+    file.assert == __FILE__
+    line.assert == 13
+    meth.assert == :source_location_example
+  end
+
+  def source_location_example
+    source_location
+  end
+
+end

data/test/core/kernel/test_super_method.rb

@@ -0,0 +1,20 @@
+covers 'facets/kernel/super_method'
+
+tests Kernel do
+
+  context "class heirarchy" do
+    q1 = Class.new{ def x ; 1 ; end }
+    q2 = Class.new(q1){ def x ; 2 ; end }
+    q3 = Class.new(q2){ def x ; 3 ; end }
+    [q1, q2, q3]
+  end
+
+  unit :super_method do |q|
+    x = q[0].new
+    z = q[2].new
+    s0 = x.method(:x)
+    s1 = z.super_method(q[0], :x)
+    s1.call.assert == s0.call
+  end
+
+end

data/test/core/kernel/test_tap.rb

@@ -1,19 +1,34 @@
-require 'facets/kernel/tap'
-require 'test/unit'
+covers 'facets/kernel/tap'
 
-class TestKernelTap < Test::Unit::TestCase
+testcase Kernel do
 
-  def test_tap
-    x = "foo"
-    r = ("foobar".tap{ |x| x.gsub!(/bar/, '') })
-    assert_equal(x, r)
+  unit :tap do
+    e = "foo"
+    r = "foobar".tap{ |x| x.gsub!(/bar/, '') }
+    r.assert == e
   end
 
-  def test_tap_array
+  unit :tap => "check internal value" do
     x = [1,2,3]
     x.tap{ |a|
-      assert_equal(x, a)
+      a.assert == x
     }
   end
 
+  unit :tap => "assign via tap block" do
+    bob = Struct.new(:name, :address, :zip).new
+
+    x = lambda do |s|
+      s.name    = "Bob Sawyer"
+      s.address = "123 Maple, Anytown NC"
+      s.zip     = "12345" 
+    end
+
+    bob.tap(&x)
+
+    bob.name.assert == "Bob Sawyer"
+    bob.address.assert == "123 Maple, Anytown NC"
+    bob.zip.assert == "12345"
+  end
+
 end

data/test/core/kernel/test_temporarily.rb

@@ -0,0 +1,21 @@
+covers 'facets/kernel/temporarily'
+
+tests Kernel do
+
+  unit :temporarily => "global variable" do
+    $temporary_variable = true
+    temporarily('$temporary_variable'=>false) do
+      $temporary_variable.assert == false
+    end
+    $temporary_variable.assert == true
+  end
+
+  unit :temporarily => "instance variable" do
+    @x = 1
+    temporarily('@x'=>2) do
+      @x.assert == 2
+    end
+    @x.assert == 1
+  end
+
+end

data/test/core/kernel/test_true.rb

@@ -0,0 +1,23 @@
+covers 'facets/kernel/true'
+
+testcase Kernel do
+
+  unit :true? => "nothing is true? but true itself" do
+    true.assert.true?
+
+    nil.refute.true?
+    false.refute.true?
+    1.refute.true?
+    :a.refute.true?
+  end
+
+  unit :false? => "nothing is false? but false itself" do
+    false.assert.false?
+
+    nil.refute.false?
+    true.refute.false?
+    1.refute.false?
+    :a.refute.false?
+  end
+
+end

data/test/core/kernel/test_try.rb

@@ -0,0 +1,27 @@
+covers 'facets/kernel/try'
+
+tests Kernel do
+
+  unit :try do
+    example = Struct.new(:name).new("bob")
+    example.try(:name).assert == "bob"
+  end
+
+  unit :try => "without argument" do
+    example = Struct.new(:name).new("bob")
+    example.try.name.assert == "bob"
+  end
+
+end
+
+tests NilClass do
+
+  unit :try do
+    nil.try(:name).assert == nil
+  end
+
+  unit :try => "without argument" do
+    nil.try.name.assert == nil
+  end
+
+end

data/test/core/kernel/test_try_dup.rb

@@ -0,0 +1,46 @@
+covers 'facets/kernel/try_dup'
+
+tests Kernel do
+  unit :try_dup do
+    obj1 = Object.new
+    obj2 = obj1.try_dup
+    obj2.equal?(obj1).assert == false
+  end
+
+  unit :dup! do
+    obj1 = Object.new
+    obj2 = obj1.dup!
+    obj2.equal?(obj1).assert == false
+  end
+end
+
+tests TrueClass do
+  unit :try_dup do
+    true.try_dup.assert == true
+  end
+end
+
+tests FalseClass do
+  unit :try_dup do
+    false.try_dup.assert == false
+  end
+end
+
+tests NilClass do
+  unit :try_dup do
+    nil.try_dup.assert == nil
+  end
+end
+
+tests Numeric do
+  unit :try_dup do
+    10.try_dup.assert == 10
+  end
+end
+
+tests Symbol do
+  unit :try_dup do
+    :A.try_dup.assert == :A
+  end
+end
+

data/test/core/kernel/test_val.rb

@@ -1,27 +1,26 @@
-require 'facets/kernel/val.rb'
-require 'test/unit'
+covers 'facets/kernel/val'
 
-class TestKernelVal < Test::Unit::TestCase
+testcase Kernel do
 
-  def test_val_1
+  unit :val? => "of nil" do
     f = nil
     t = 1
-    assert( ! f.val? )
-    assert( t.val? )
+    f.refute.val?
+    t.assert.val?
   end
 
-  def test_val_2
+  unit :val? => "of empty array" do
     f = []
     t = [1]
-    assert( ! f.val? )
-    assert( t.val? )
+    f.refute.val?
+    t.assert.val?
   end
 
-  def test_val_3
+  unit :val? => "of empty string" do
     f = ''
     t = '1'
-    assert( ! f.val? )
-    assert( t.val? )
+    f.refute.val?
+    t.assert.val? 
   end
 
 end

data/test/core/kernel/test_with.rb

@@ -0,0 +1,14 @@
+covers 'facets/kernel/with'
+
+tests Kernel do
+
+  unit :with do
+    with values = [] do
+      self << 'bar'
+      self << 'baz'
+    end
+    values.assert == ['bar', 'baz']
+  end
+
+end
+

data/test/core/kernel/test_writers.rb

@@ -0,0 +1,49 @@
+covers 'facets/kernel/writers'
+
+tests Kernel do
+
+  unit :writers do
+    c = Class.new do
+      attr_accessor :a
+      def b=(b); @b=b; end
+    end
+    o = c.new
+    w = o.writers
+
+    w.assert.include?(:a=)
+    w.assert.include?(:b=)
+  end
+
+  unit :writers do
+    c = Class.new do
+      attr_accessor :a
+      def b=(b); @b=b; end
+      private
+      def q=(q); @q=q; end
+    end
+    o = c.new
+    w = o.writers(:access=>:private)
+
+    w.refute.include?(:a=)
+    w.refute.include?(:b=)
+    w.assert.include?(:q=)
+  end
+
+  unit :writers do
+    c = Class.new do
+      attr_accessor :a
+      def b=(b); @b=b; end
+      private
+      def q=(q); @q=q; end
+    end
+    o = c.new
+    w = o.writers(:access=>:all)
+
+    w.assert.include?(:a=)
+    w.assert.include?(:b=)
+    w.assert.include?(:q=)
+  end
+
+  # TODO: Need to test more options
+
+end

data/test/core/matchdata/test_match.rb

@@ -1,14 +1,10 @@
-# Test for lib/facets/matchdata/matchset
+covers 'facets/matchdata/match'
 
-require 'facets/matchdata/match.rb'
+testcase MatchData do
 
-require 'test/unit'
-
-class Test_MatchData_Match < Test::Unit::TestCase
-
-  def test_match
+  unit :match do
     md = /X(a)(b)(c)X/.match("YXabcXY")
-    assert_equal( "XabcX", md.match )
+    md.match.assert == "XabcX"
   end
 
 end