* Merge YARV

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11439 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 316 insertions, 0 deletions

diff --git a/test/ruby/test_module.rb b/test/ruby/test_module.rb
new file mode 100644
index 0000000000..471d6f6481
--- /dev/null
+++ b/test/ruby/test_module.rb
@@ -0,0 +1,316 @@
+require 'test/unit'
+require 'pp'
+
+$m0 = Module.nesting
+
+class TestModule < Test::Unit::TestCase
+
+  def test_LT_0
+    assert_equal true, String < Object
+    assert_equal false, Object < String
+    assert_nil String < Array
+    assert_equal true, Array < Enumerable
+    assert_equal false, Enumerable < Array
+    assert_nil Proc < Comparable
+    assert_nil Comparable < Proc
+  end
+
+  def test_GT_0
+    assert_equal false, String > Object
+    assert_equal true, Object > String
+    assert_nil String > Array
+    assert_equal false, Array > Enumerable
+    assert_equal true, Enumerable > Array
+    assert_nil Comparable > Proc
+    assert_nil Proc > Comparable
+  end
+
+  def test_CMP_0
+    assert_equal -1, (String <=> Object)
+    assert_equal 1, (Object <=> String)
+    assert_nil(Array <=> String)
+  end
+
+  ExpectedException = NoMethodError
+
+  # Support stuff
+
+  def remove_pp_mixins(list)
+    list.reject {|c| c == PP::ObjectMixin }
+  end
+
+  module Mixin
+    MIXIN = 1
+    def mixin
+    end
+  end
+
+  module User
+    USER = 2
+    include Mixin
+    def user
+    end
+  end
+
+  module Other
+    def other
+    end
+  end
+
+  class AClass
+    def AClass.cm1
+      "cm1"
+    end
+    def AClass.cm2
+      cm1 + "cm2" + cm3
+    end
+    def AClass.cm3
+      "cm3"
+    end
+    
+    private_class_method :cm1, "cm3"
+
+    def aClass
+    end
+
+    def aClass1
+    end
+
+    def aClass2
+    end
+
+    private :aClass1
+    protected :aClass2
+  end
+
+  class BClass < AClass
+    def bClass1
+    end
+
+    private
+
+    def bClass2
+    end
+
+    protected
+    def bClass3
+    end
+  end
+
+  MyClass = AClass.clone
+  class MyClass
+    public_class_method :cm1
+  end
+
+  # -----------------------------------------------------------
+
+  def test_CMP # '<=>'
+    assert_equal( 0, Mixin <=> Mixin)
+    assert_equal(-1, User <=> Mixin)
+    assert_equal( 1, Mixin <=> User)
+
+    assert_equal( 0, Object <=> Object)
+    assert_equal(-1, String <=> Object)
+    assert_equal( 1, Object <=> String)
+  end
+
+  def test_GE # '>='
+    assert(Mixin >= User)
+    assert(Mixin >= Mixin)
+    assert(!(User >= Mixin))
+
+    assert(Object >= String)
+    assert(String >= String)
+    assert(!(String >= Object))
+  end
+
+  def test_GT # '>'
+    assert(Mixin   > User)
+    assert(!(Mixin > Mixin))
+    assert(!(User  > Mixin))
+
+    assert(Object > String)
+    assert(!(String > String))
+    assert(!(String > Object))
+  end
+
+  def test_LE # '<='
+    assert(User <= Mixin)
+    assert(Mixin <= Mixin)
+    assert(!(Mixin <= User))
+
+    assert(String <= Object)
+    assert(String <= String)
+    assert(!(Object <= String))
+  end
+
+  def test_LT # '<'
+    assert(User < Mixin)
+    assert(!(Mixin < Mixin))
+    assert(!(Mixin < User))
+
+    assert(String < Object)
+    assert(!(String < String))
+    assert(!(Object < String))
+  end
+
+  def test_VERY_EQUAL # '==='
+    assert(Object === self)
+    assert(Test::Unit::TestCase === self)
+    assert(TestModule === self)
+    assert(!(String === self))
+  end
+
+  def test_ancestors
+    assert_equal([User, Mixin],      User.ancestors)
+    assert_equal([Mixin],            Mixin.ancestors)
+
+    assert_equal([Object, Kernel, BasicObject], remove_pp_mixins(Object.ancestors))
+    assert_equal([String, Comparable, Object, Kernel, BasicObject],
+                 remove_pp_mixins(String.ancestors))
+  end
+
+  def test_class_eval
+    Other.class_eval("CLASS_EVAL = 1")
+    assert_equal(1, Other::CLASS_EVAL)
+    assert(Other.constants.include?("CLASS_EVAL"))
+  end
+
+  def test_class_variable_set
+    # TODO
+  end
+
+  def test_class_variable_get
+    # TODO
+  end
+
+  def test_const_defined?
+    assert(Math.const_defined?(:PI))
+    assert(Math.const_defined?("PI"))
+    assert(!Math.const_defined?(:IP))
+    assert(!Math.const_defined?("IP"))
+  end
+
+  def test_const_get
+    assert_equal(Math::PI, Math.const_get("PI"))
+    assert_equal(Math::PI, Math.const_get(:PI))
+  end
+
+  def test_const_set
+    assert(!Other.const_defined?(:KOALA))
+    Other.const_set(:KOALA, 99)
+    assert(Other.const_defined?(:KOALA))
+    assert_equal(99, Other::KOALA)
+    Other.const_set("WOMBAT", "Hi")
+    assert_equal("Hi", Other::WOMBAT)
+  end
+
+  def test_constants
+    assert_equal(["MIXIN"], Mixin.constants)
+    assert_equal(["MIXIN", "USER"], User.constants.sort)
+  end
+
+  def test_included_modules
+    assert_equal([], Mixin.included_modules)
+    assert_equal([Mixin], User.included_modules)
+    assert_equal([Kernel], remove_pp_mixins(Object.included_modules))
+    assert_equal([Comparable, Kernel],
+                 remove_pp_mixins(String.included_modules))
+  end
+
+  def test_instance_methods
+    assert_equal(["user" ], User.instance_methods(false))
+    assert_equal(["user", "mixin"].sort, User.instance_methods(true).sort)
+    assert_equal(["mixin"], Mixin.instance_methods)
+    assert_equal(["mixin"], Mixin.instance_methods(true))
+    # Ruby 1.8 feature change:
+    # #instance_methods includes protected methods.
+    #assert_equal(["aClass"], AClass.instance_methods(false))
+    assert_equal(["aClass", "aClass2"], AClass.instance_methods(false).sort)
+    assert_equal(["aClass", "aClass2"],
+        (AClass.instance_methods(true) - Object.instance_methods(true)).sort)
+  end
+
+  def test_method_defined?
+    assert(!User.method_defined?(:wombat))
+    assert(User.method_defined?(:user))
+    assert(User.method_defined?(:mixin))
+    assert(!User.method_defined?("wombat"))
+    assert(User.method_defined?("user"))
+    assert(User.method_defined?("mixin"))
+  end
+
+  def test_module_eval
+    User.module_eval("MODULE_EVAL = 1")
+    assert_equal(1, User::MODULE_EVAL)
+    assert(User.constants.include?("MODULE_EVAL"))
+    User.instance_eval("remove_const(:MODULE_EVAL)")
+    assert(!User.constants.include?("MODULE_EVAL"))
+  end
+
+  def test_name
+    assert_equal("Fixnum", Fixnum.name)
+    assert_equal("TestModule::Mixin",  Mixin.name)
+    assert_equal("TestModule::User",   User.name)
+  end
+
+  def test_private_class_method
+    assert_raise(ExpectedException) { AClass.cm1 }
+    assert_raise(ExpectedException) { AClass.cm3 }
+    assert_equal("cm1cm2cm3", AClass.cm2)
+  end
+
+  def test_private_instance_methods
+    assert_equal(["aClass1"], AClass.private_instance_methods(false))
+    assert_equal(["bClass2"], BClass.private_instance_methods(false))
+    assert_equal(["aClass1", "bClass2"],
+        (BClass.private_instance_methods(true) -
+         Object.private_instance_methods(true)).sort)
+  end
+
+  def test_protected_instance_methods
+    assert_equal(["aClass2"], AClass.protected_instance_methods)
+    assert_equal(["bClass3"], BClass.protected_instance_methods(false))
+    assert_equal(["bClass3", "aClass2"].sort,
+                 (BClass.protected_instance_methods(true) -
+                  Object.protected_instance_methods(true)).sort)
+  end
+
+  def test_public_class_method
+    assert_equal("cm1",       MyClass.cm1)
+    assert_equal("cm1cm2cm3", MyClass.cm2)
+    assert_raise(ExpectedException) { eval "MyClass.cm3" }
+  end
+
+  def test_public_instance_methods
+    assert_equal(["aClass"],  AClass.public_instance_methods(false))
+    assert_equal(["bClass1"], BClass.public_instance_methods(false))
+  end
+
+  def test_s_constants
+    c1 = Module.constants
+    Object.module_eval "WALTER = 99"
+    c2 = Module.constants
+    assert_equal(["WALTER"], c2 - c1)
+  end
+
+  module M1
+    $m1 = Module.nesting
+    module M2
+      $m2 = Module.nesting
+    end
+  end
+
+  def test_s_nesting
+    assert_equal([],                               $m0)
+    assert_equal([TestModule::M1, TestModule],     $m1)
+    assert_equal([TestModule::M1::M2,
+                  TestModule::M1, TestModule],     $m2)
+  end
+
+  def test_s_new
+    m = Module.new
+    assert_instance_of(Module, m)
+  end
+
+end