1 files changed, 165 insertions, 16 deletions
diff --git a/test/ruby/test_alias.rb b/test/ruby/test_alias.rb
index 1fbad8be53..539cd49488 100644
--- a/test/ruby/test_alias.rb
+++ b/test/ruby/test_alias.rb
@@ -1,5 +1,5 @@
+# frozen_string_literal: false
 require 'test/unit'
-require 'envutil'
 
 class TestAlias < Test::Unit::TestCase
   class Alias0
@@ -35,6 +35,18 @@ class TestAlias < Test::Unit::TestCase
     end
   end
 
+  class Alias4 < Alias0
+    alias foo1 foo
+    alias foo2 foo1
+    alias foo3 foo2
+  end
+
+  class Alias5 < Alias4
+    alias foo1 foo
+    alias foo3 foo2
+    alias foo2 foo1
+  end
+
   def test_alias
     x = Alias2.new
     assert_equal "foo", x.bar
@@ -47,20 +59,18 @@ class TestAlias < Test::Unit::TestCase
     assert_raise(NoMethodError) { x.quux }
   end
 
-  class C
-    def m
-      $SAFE
-    end
-  end
-
-  def test_JVN_83768862
-    d = lambda {
-      $SAFE = 4
-      dclass = Class.new(C)
-      dclass.send(:alias_method, :mm, :m)
-      dclass.new
-    }.call
-    assert_raise(SecurityError) { d.mm }
+  def test_alias_inspect
+    o = Alias4.new
+    assert_equal("TestAlias::Alias4(TestAlias::Alias0)#foo()", o.method(:foo).inspect.split[1])
+    assert_equal("TestAlias::Alias4(TestAlias::Alias0)#foo1(foo)()", o.method(:foo1).inspect.split[1])
+    assert_equal("TestAlias::Alias4(TestAlias::Alias0)#foo2(foo)()", o.method(:foo2).inspect.split[1])
+    assert_equal("TestAlias::Alias4(TestAlias::Alias0)#foo3(foo)()", o.method(:foo3).inspect.split[1])
+
+    o = Alias5.new
+    assert_equal("TestAlias::Alias5(TestAlias::Alias0)#foo()", o.method(:foo).inspect.split[1])
+    assert_equal("TestAlias::Alias5(TestAlias::Alias0)#foo1(foo)()", o.method(:foo1).inspect.split[1])
+    assert_equal("TestAlias::Alias5(TestAlias::Alias0)#foo2(foo)()", o.method(:foo2).inspect.split[1])
+    assert_equal("TestAlias::Alias5(TestAlias::Alias0)#foo3(foo)()", o.method(:foo3).inspect.split[1])
   end
 
   def test_nonexistmethod
@@ -131,6 +141,19 @@ class TestAlias < Test::Unit::TestCase
     assert_equal([:Base, :M], SuperInAliasedModuleMethod::Derived.new.bar)
   end
 
+  def test_alias_wb_miss
+    assert_normal_exit "#{<<-"begin;"}\n#{<<-'end;'}"
+    begin;
+      require 'stringio'
+      GC.verify_internal_consistency
+      GC.start
+      class StringIO
+        alias_method :read_nonblock, :sysread
+      end
+      GC.verify_internal_consistency
+    end;
+  end
+
   def test_cyclic_zsuper
     bug9475 = '[ruby-core:60431] [Bug #9475]'
 
@@ -181,7 +204,8 @@ class TestAlias < Test::Unit::TestCase
   def test_alias_in_module
     bug9663 = '[ruby-core:61635] [Bug #9663]'
 
-    assert_separately(['-', bug9663], <<-'end;')
+    assert_separately(['-', bug9663], "#{<<-"begin;"}\n#{<<-'end;'}")
+    begin;
       bug = ARGV[0]
 
       m = Module.new do
@@ -192,4 +216,129 @@ class TestAlias < Test::Unit::TestCase
       assert_equal(o.to_s, o.orig_to_s, bug)
     end;
   end
+
+  class C0; def foo; end; end
+  class C1 < C0; alias bar foo; end
+
+  def test_alias_method_equation
+    obj = C1.new
+    assert_equal(obj.method(:bar), obj.method(:foo))
+    assert_equal(obj.method(:foo), obj.method(:bar))
+  end
+
+  def test_alias_class_method_added
+    name = nil
+    k = Class.new {
+      def foo;end
+      def self.method_added(mid)
+        @name = instance_method(mid).original_name
+      end
+      alias bar foo
+      name = @name
+    }
+    assert_equal(:foo, k.instance_method(:bar).original_name)
+    assert_equal(:foo, name)
+  end
+
+  def test_alias_module_method_added
+    name = nil
+    k = Module.new {
+      def foo;end
+      def self.method_added(mid)
+        @name = instance_method(mid).original_name
+      end
+      alias bar foo
+      name = @name
+    }
+    assert_equal(:foo, k.instance_method(:bar).original_name)
+    assert_equal(:foo, name)
+  end
+
+  def test_alias_suppressing_redefinition
+    assert_in_out_err(%w[-w], "#{<<~"begin;"}\n#{<<~'end;'}")
+    begin;
+      class A
+        def foo; end
+        alias foo foo
+        def foo; end
+      end
+    end;
+  end
+
+  class C2
+    public :system
+    alias_method :bar, :system
+    alias_method :system, :bar
+  end
+
+  def test_zsuper_alias_visibility
+    assert(C2.new.respond_to?(:system))
+  end
+
+  def test_alias_memory_leak
+    assert_no_memory_leak([], "#{<<~"begin;"}", "#{<<~'end;'}", rss: true)
+    begin;
+      class A
+        500.times do
+          1000.times do |i|
+            define_method(:"foo_#{i}") {}
+
+            alias :"foo_#{i}" :"foo_#{i}"
+
+            remove_method :"foo_#{i}"
+          end
+          GC.start
+        end
+      end
+    end;
+  end
+
+  def test_alias_complemented_method
+    assert_in_out_err(%w[-w], "#{<<~"begin;"}\n#{<<~'end;'}")
+    begin;
+      module M
+        def foo = 1
+        self.extend M
+      end
+
+      3.times{|i|
+        module M
+          alias foo2 foo
+          remove_method :foo
+          def foo = 2
+        ensure
+          remove_method :foo
+          alias foo foo2
+          remove_method :foo2
+        end
+
+        M.foo
+
+        original_foo = M.method(:foo)
+
+        M.class_eval do
+          remove_method :foo
+          def foo = 3
+        end
+
+        M.class_eval do
+          remove_method :foo
+          define_method :foo, original_foo
+        end
+      }
+    end;
+  end
+
+  def test_undef_method_error_message_with_zsuper_method
+    modules = [
+      Module.new { private :class },
+      Module.new { prepend Module.new { private :class } },
+    ]
+    message = "undefined method 'class' for module '%s'"
+    modules.each do |mod|
+      assert_raise_with_message(NameError, message % mod) do
+        mod.alias_method :xyz, :class
+      end
+    end
+  end
 end