1require 'test/unit' 2require 'envutil' 3 4class TestAlias < Test::Unit::TestCase 5 class Alias0 6 def foo 7 "foo" 8 end 9 end 10 11 class Alias1 < Alias0 12 alias bar foo 13 14 def foo 15 "foo+#{super}" 16 end 17 end 18 19 class Alias2 < Alias1 20 alias baz foo 21 undef foo 22 end 23 24 class Alias3 < Alias2 25 def foo 26 super 27 end 28 29 def bar 30 super 31 end 32 33 def quux 34 super 35 end 36 end 37 38 def test_alias 39 x = Alias2.new 40 assert_equal "foo", x.bar 41 assert_equal "foo+foo", x.baz 42 assert_equal "foo+foo", x.baz # test_check for cache 43 44 x = Alias3.new 45 assert_raise(NoMethodError) { x.foo } 46 assert_equal "foo", x.bar 47 assert_raise(NoMethodError) { x.quux } 48 end 49 50 class C 51 def m 52 $SAFE 53 end 54 end 55 56 def test_JVN_83768862 57 d = lambda { 58 $SAFE = 4 59 dclass = Class.new(C) 60 dclass.send(:alias_method, :mm, :m) 61 dclass.new 62 }.call 63 assert_raise(SecurityError) { d.mm } 64 end 65 66 def test_nonexistmethod 67 assert_raise(NameError){ 68 Class.new{ 69 alias_method :foobarxyzzy, :barbaz 70 } 71 } 72 end 73 74 def test_send_alias 75 x = "abc" 76 class << x 77 alias_method :try, :__send__ 78 end 79 assert_equal("ABC", x.try(:upcase), '[ruby-dev:38824]') 80 end 81 82 def test_special_const_alias 83 assert_raise(TypeError) do 84 1.instance_eval do 85 alias to_string to_s 86 end 87 end 88 end 89 90 def test_alias_with_zsuper_method 91 c = Class.new 92 c.class_eval do 93 def foo 94 :ok 95 end 96 def bar 97 :ng 98 end 99 private :foo 100 end 101 d = Class.new(c) 102 d.class_eval do 103 public :foo 104 alias bar foo 105 end 106 assert_equal(:ok, d.new.bar) 107 end 108 109 module SuperInAliasedModuleMethod 110 module M 111 def foo 112 super << :M 113 end 114 115 alias bar foo 116 end 117 118 class Base 119 def foo 120 [:Base] 121 end 122 end 123 124 class Derived < Base 125 include M 126 end 127 end 128 129 # [ruby-dev:46028] 130 def test_super_in_aliased_module_method # fails in 1.8 131 assert_equal([:Base, :M], SuperInAliasedModuleMethod::Derived.new.bar) 132 end 133 134 def test_cyclic_zsuper 135 bug9475 = '[ruby-core:60431] [Bug #9475]' 136 137 a = Module.new do 138 def foo 139 "A" 140 end 141 end 142 143 b = Class.new do 144 include a 145 attr_reader :b 146 147 def foo 148 @b ||= 0 149 raise SystemStackError if (@b += 1) > 1 150 # "foo from B" 151 super + "B" 152 end 153 end 154 155 c = Class.new(b) do 156 alias orig_foo foo 157 158 def foo 159 # "foo from C" 160 orig_foo + "C" 161 end 162 end 163 164 b.class_eval do 165 alias orig_foo foo 166 attr_reader :b2 167 168 def foo 169 @b2 ||= 0 170 raise SystemStackError if (@b2 += 1) > 1 171 # "foo from B (again)" 172 orig_foo + "B2" 173 end 174 end 175 176 assert_nothing_raised(SystemStackError, bug9475) do 177 assert_equal("ABC", c.new.foo, bug9475) 178 end 179 end 180 181 def test_alias_in_module 182 bug9663 = '[ruby-core:61635] [Bug #9663]' 183 184 assert_separately(['-', bug9663], <<-'end;') 185 bug = ARGV[0] 186 187 m = Module.new do 188 alias orig_to_s to_s 189 end 190 191 o = Object.new.extend(m) 192 assert_equal(o.to_s, o.orig_to_s, bug) 193 end; 194 end 195end 196