facets 2.8.4 → 2.9.0.pre.1

data/test/core/matchdata/test_matchset.rb

@@ -1,21 +1,19 @@
-require 'facets/matchdata/matchset'
-require 'test/unit'
+covers 'facets/matchdata/matchset'
 
-class Test_MatchData_Matchset < Test::Unit::TestCase
+testcase MatchData do
 
-  def test_matchtree_01
+  unit :matchtree do
     md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
-    assert_equal( [["bb"], ["cc", ["dd"]], ["ee"]] , md.matchtree )
-  end
+    md.matchtree.assert == [["bb"], ["cc", ["dd"]], ["ee"]]
 
-  def test_matchtree_02
     md = /(bb)c(c(dd))(ee)/.match "XXaabbccddeeffXX"
-    assert_equal( [["bb"], "c", ["c", ["dd"]], ["ee"]] , md.matchtree )
+    md.matchtree.assert == [["bb"], "c", ["c", ["dd"]], ["ee"]]
   end
 
-  def test_matchset
+  unit :matchset do
     md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
-    assert_equal( ["XXaa", [["bb"], ["cc", ["dd"]], ["ee"]], "ffXX"] , md.matchset )
+    md.matchset.assert == ["XXaa", [["bb"], ["cc", ["dd"]], ["ee"]], "ffXX"]
   end
 
 end
+

data/test/core/module/test_abstract.rb

@@ -1,23 +1,20 @@
-# Test for facets/module/abstract
+covers 'facets/module/abstract'
 
-require 'facets/module/abstract.rb'
+testcase Module do
 
-require 'test/unit'
-
-class TestAttrTester < Test::Unit::TestCase
-
-  class Aq
-    abstract :q
+  unit :abstract => "in a module" do
+    m = Module.new{ abstract :q }
+    c = Class.new{ include m }
+    x = c.new
+    TypeError.assert.raised?{ x.q }
   end
 
-  def test_abstract_01
-    ac = Aq.new
-    assert_raises( TypeError ) { ac.q }
-  end
-
-  def test_abstract_02
-    ac = Class.new { abstract :q }.new
-    assert_raises( TypeError ) { ac.q }
+  unit :abstract => "in a class" do
+    c = Class.new{ abstract :q }
+    #c.pry.abstract :q
+    x = c.new
+    TypeError.assert.raised?{ x.q }
   end
 
 end
+

data/test/core/module/test_alias_accessor.rb

@@ -1,21 +1,22 @@
-require 'facets/module/alias_accessor'
-require 'test/unit'
+covers 'facets/module/alias_accessor'
 
-class Test_Module_Alias_Accessor < Test::Unit::TestCase
+testcase Module do
 
-  class X
-    attr_accessor :x
-    alias_accessor :y, :x
-  end
+  unit :alias_accessor do
+    c = Class.new do
+      attr_accessor :x
+      alias_accessor :y, :x
+    end
+
+    x = c.new
 
-  def test_alias_accessor
-    x = X.new
     x.x = 10
-    assert_equal( 10, x.x )
-    assert_equal( 10, x.y )
+    x.x.assert == 10
+    x.y.assert == 10
+
     x.y = 20
-    assert_equal( 20, x.x )
-    assert_equal( 20, x.y )
+    x.x.assert == 20
+    x.y.assert == 20
   end
 
 end

data/test/core/module/test_alias_method_chain.rb

@@ -1,29 +1,30 @@
-require 'facets/module/alias_method_chain'
-require 'test/unit'
+covers 'facets/module/alias_method_chain'
 
-class Test_Module_Alias_Method_Chain < Test::Unit::TestCase
+testcase Module do
 
-  module X
-    def self.included(base)
-      base.module_eval {
-        alias_method_chain :foo, :feature
-      }
-    end
-    def foo_with_feature
-      foo_without_feature + '!'
+  unit :alias_method_chain do
+
+    x = Module.new do
+      def self.included(base)
+        base.module_eval {
+          alias_method_chain :foo, :feature
+        }
+      end
+      def foo_with_feature
+        foo_without_feature + '!'
+      end
     end
-  end
 
-  class Y
-    def foo
-      "FOO"
+    y = Class.new do
+      def foo
+        "FOO"
+      end
+      include x
     end
-    include X
-  end
 
-  def test_alias_method_chian
-    y = Y.new
-    assert_equal( "FOO!", y.foo )
+    iy = y.new
+
+    iy.foo.assert == "FOO!"
   end
 
 end

data/test/core/module/test_alias_module_function.rb

@@ -1,18 +1,20 @@
-require 'facets/module/alias_module_function'
-require 'test/unit'
+covers 'facets/module/alias_module_function'
 
-class Test_Module_Alias_Module_Function < Test::Unit::TestCase
+testcase Module do
 
-  module MockModule
-    # for alias_module_method
-    def x ; 33 ; end
-    module_function :x
-    alias_module_function :y, :x
-  end
+  unit :alias_module_function do
+    m = Module.new do
+      def x ; 33 ; end
+
+      module_function :x
+
+      alias_module_function :y, :x
+    end
+
+    m.y.assert == 33
 
-  def test_alias_module_function
-    assert_equal( 33, MockModule.y )
-    #assert_equal( 33, @m.send(:y) ) # use send b/c private
+    # use send b/c private?
+    #@m.send(:y).assert == 33
   end
 
 end

data/test/core/module/test_all_instance_methods.rb

@@ -0,0 +1,23 @@
+covers 'facets/module/all_instance_methods'
+
+tests Module do
+
+  unit :all_instance_methods do
+    c = Class.new do
+      def x; "x"; end
+      private
+      def y; "y"; end
+      protected
+      def z; "z"; end
+    end
+
+    list = c.all_instance_methods(false)
+
+    list.map!{ |m| m.to_sym } # b/c of diff in 1.8 vs 1.9
+
+    list.assert.include?(:x)
+    list.assert.include?(:y)
+    list.assert.include?(:z)
+  end
+
+end

data/test/core/module/test_ancestor.rb

@@ -1,10 +1,11 @@
-require 'facets/module/ancestor.rb'
-require 'test/unit'
+covers 'facets/module/ancestor'
 
-class TestInclude < Test::Unit::TestCase
+testcase Module do
 
-  def test_ancestor
-    assert( self.class.ancestor?(::Test::Unit::TestCase) )
+  unit :ancestor? do
+    c1 = Class.new
+    c2 = Class.new(c1)
+    c2.assert.ancestor?(c1)
   end
 
 end

data/test/core/module/test_anonymous.rb

@@ -0,0 +1,14 @@
+covers 'facets/module/anonymous'
+
+tests Module do
+
+  unit :anonymous? do
+    m = Module.new
+    m.assert.anonymous?
+  end
+
+  unit :anonymous? do
+    Lemon.refute.anonymous?
+  end
+
+end

data/test/core/module/test_attr_setter.rb

@@ -0,0 +1,24 @@
+covers 'facets/module/attr_setter'
+
+tests Module do
+
+  unit :attr_setter do
+    c = Class.new do
+      attr_setter :a
+    end
+    x = c.new
+    x.a(1)
+    x.a.assert == 1
+  end
+
+  unit :alias_setter do
+    c = Class.new do
+      attr_setter :a
+      alias_setter :b, :a
+    end
+    x = c.new
+    x.b(1)
+    x.a.assert == 1
+  end
+
+end

data/test/core/module/test_basename.rb

@@ -1,10 +1,9 @@
-require 'facets/module/basename.rb'
-require 'test/unit'
+covers 'facets/module/basename'
 
-class TestModuleBasename < Test::Unit::TestCase
+tests Module do
 
-  def test_basename
-    assert_equal( "TestCase", ::Test::Unit::TestCase.basename )
+  unit :basename do
+    Lemon::TestCase.basename.assert == "TestCase"
   end
 
 end

data/test/core/module/test_can.rb

@@ -1,18 +1,17 @@
-require 'facets/module/can'
-require 'test/unit'
+covers 'facets/module/can'
 
-class Test_Module_Can < Test::Unit::TestCase
+testcase Module do
 
-  module M 
-    def x; "x"; end 
-  end
+  unit :can do
+    m = Module.new do
+      def x; "x"; end 
+    end
 
-  class X
-    can M
-  end
+    c = Class.new do
+      can m
+    end
 
-  def test_can
-    assert("x", X.x)
+    c.x.assert == "x"
   end
 
 end

data/test/core/module/test_class.rb

@@ -1,20 +1,17 @@
-require 'facets/module/class'
-require 'test/unit'
+covers 'facets/module/class'
 
-class Test_Module_Class < Test::Unit::TestCase
+testcase Module do
 
-  class X
-  end
+  unit :class? do
+    x_class = Class.new
+    y_class = Class.new(x_class)
 
-  class Y < X
-  end
+    x = x_class.new
+    y = y_class.new
 
-  def test_class?
-    x = X.new
-    y = Y.new
-    assert( X.class?(x) )
-    assert( Y.class?(y) )
-    assert( Y.class?(y) )
+    x_class.assert.class?(x)
+    y_class.assert.class?(y)
+    y_class.assert.class?(y)
   end
 
 end

data/test/core/module/test_class_def.rb

@@ -0,0 +1,18 @@
+covers 'facets/module/class_def'
+
+tests Module do
+
+  unit :class_def do
+    m = Module.new
+    m.class_def(:x){"x"}
+    c = Class.new{ include m }
+    c.new.x.assert == "x"
+  end
+
+  unit :class_def do
+    c = Class.new
+    c.class_def(:x){"x"}
+    c.new.x.assert == "x"
+  end
+
+end

data/test/core/module/test_instance_method.rb

@@ -0,0 +1,16 @@
+covers 'facets/module/instance_method'
+
+tests Module do
+
+  unit :instance_method! do
+    c = Class.new do
+      def x; "x"; end
+    end
+
+    x1 = c.instance_method!(:x)
+    x2 = c.instance_method!(:x)
+
+    x1.object_id.assert == x2.object_id
+  end
+
+end

data/test/core/module/test_instance_method_defined.rb

@@ -0,0 +1,26 @@
+covers 'facets/module/instance_method_defined'
+
+tests Module do
+
+  unit :instance_method_defined? do
+    c = Class.new do
+      def x; "x"; end
+    end
+    c.assert.instance_method_defined?(:x)
+  end
+
+  unit :singleton_method_defined? do
+    c = Class.new do
+      def self.x; "x"; end
+    end
+    c.assert.singleton_method_defined?(:x)
+  end
+
+  unit :module_method_defined? => "alias for #singleton_method_defined" do
+    c = Class.new do
+      def self.x; "x"; end
+    end
+    c.assert.module_method_defined?(:x)
+  end
+
+end

data/test/core/module/test_integrate.rb

@@ -1,22 +1,23 @@
-require 'facets/module/integrate'
-require 'test/unit'
+covers 'facets/module/integrate'
 
-class Test_Module_Integrate < Test::Unit::TestCase
+testcase Module do
 
-  module M
-    def x ; 1 ; end
-  end
+  unit :integrate do
+    m = Module.new do
+      def x ; 1 ; end
+    end
 
-  class C
-    integrate M do
-      rename :y, :x
+    c = Class.new do
+      integrate m do
+        rename :y, :x
+      end
     end
-  end
 
-  def test_integrate
-    c = C.new
-    assert_raises( NoMethodError ) { c.x }
-    assert_equal( 1, c.y )
+    ic = c.new
+
+    NoMethodError.assert.raised?{ ic.x }
+
+    ic.y.assert == 1
   end
 
 end