third-party/mruby/mrbgems/mruby-metaprog/test/metaprog.rb

   1 assert('Kernel#__send__', '15.3.1.3.4') do
   2   # test with block
   3   l = __send__(:lambda) do
   4     true
   5   end
   6
   7   assert_true l.call
   8   assert_equal Proc, l.class
   9   # test with argument
  10   assert_true __send__(:respond_to?, :nil?)
  11   # test without argument and without block
  12   assert_equal String, __send__(:to_s).class
  13 end
  14
  15 assert('Kernel#send', '15.3.1.3.44') do
  16   # test with block
  17   l = send(:lambda) do
  18     true
  19   end
  20
  21   assert_true l.call
  22   assert_equal l.class, Proc
  23   # test with argument
  24   assert_true send(:respond_to?, :nil?)
  25   # test without argument and without block
  26   assert_equal send(:to_s).class, String
  27 end
  28
  29 assert('Kernel#instance_variable_defined?', '15.3.1.3.20') do
  30   o = Object.new
  31   o.instance_variable_set(:@a, 1)
  32
  33   assert_true o.instance_variable_defined?("@a")
  34   assert_false o.instance_variable_defined?("@b")
  35   assert_true o.instance_variable_defined?("@a"[0,2])
  36   assert_true o.instance_variable_defined?("@abc"[0,2])
  37   assert_raise(NameError) { o.instance_variable_defined?("@0") }
  38 end
  39
  40 assert('Kernel#instance_variable_get', '15.3.1.3.21') do
  41   o = Class.new { attr_accessor :foo, :bar }.new
  42   o.foo = "one"
  43   o.bar = 2
  44   assert_equal("one", o.instance_variable_get(:@foo))
  45   assert_equal(2, o.instance_variable_get("@bar"))
  46   assert_equal(nil, o.instance_variable_get(:@baz))
  47   %w[foo @1].each do |n|
  48     assert_raise(NameError) { o.instance_variable_get(n) }
  49   end
  50 end
  51
  52 assert('Kernel#instance_variable_set', '15.3.1.3.22') do
  53   o = Class.new { attr_reader :foo, :_bar }.new
  54   assert_equal("one", o.instance_variable_set(:@foo, "one"))
  55   assert_equal("one", o.foo)
  56   assert_equal(2, o.instance_variable_set("@_bar", 2))
  57   assert_equal(2, o._bar)
  58   %w[@6 @% @@a @ a].each do |n|
  59     assert_raise(NameError) { o.instance_variable_set(n, 1) }
  60   end
  61 end
  62
  63 assert('Kernel#instance_variables', '15.3.1.3.23') do
  64   o = Object.new
  65   o.instance_eval do
  66     @a = 11
  67     @b = 12
  68   end
  69   ivars = o.instance_variables
  70
  71   assert_equal Array, ivars.class,
  72   assert_equal(2, ivars.size)
  73   assert_true ivars.include?(:@a)
  74   assert_true ivars.include?(:@b)
  75 end
  76
  77 assert('Kernel#methods', '15.3.1.3.31') do
  78   assert_equal Array, methods.class
  79 end
  80
  81 assert('Kernel#private_methods', '15.3.1.3.36') do
  82   assert_equal Array, private_methods.class
  83 end
  84
  85 assert('Kernel#protected_methods', '15.3.1.3.37') do
  86   assert_equal Array, protected_methods.class
  87 end
  88
  89 assert('Kernel#public_methods', '15.3.1.3.38') do
  90   assert_equal Array, public_methods.class
  91   class Foo
  92     def foo
  93     end
  94   end
  95   assert_equal [:foo], Foo.new.public_methods(false)
  96 end
  97
  98 assert('Kernel#singleton_methods', '15.3.1.3.45') do
  99   assert_equal singleton_methods.class, Array
 100 end
 101
 102 assert('Kernel.local_variables', '15.3.1.2.7') do
 103   a, b = 0, 1
 104   a += b
 105
 106   vars = Kernel.local_variables.sort
 107   assert_equal [:a, :b, :vars], vars
 108
 109   assert_equal [:a, :b, :c, :vars], Proc.new { |a, b|
 110     c = 2
 111     # Kernel#local_variables: 15.3.1.3.28
 112     local_variables.sort
 113   }.call(-1, -2)
 114 end
 115
 116 assert('Kernel#define_singleton_method') do
 117   o = Object.new
 118   ret = o.define_singleton_method(:test_method) do
 119     :singleton_method_ok
 120   end
 121   assert_equal :test_method, ret
 122   assert_equal :singleton_method_ok, o.test_method
 123 end
 124
 125 def labeled_module(name, &block)
 126   Module.new do
 127     (class <<self; self end).class_eval do
 128       define_method(:to_s) { name }
 129       alias_method :inspect, :to_s
 130     end
 131     class_eval(&block) if block
 132   end
 133 end
 134
 135 def labeled_class(name, supklass = Object, &block)
 136   Class.new(supklass) do
 137     (class <<self; self end).class_eval do
 138       define_method(:to_s) { name }
 139       alias_method :inspect, :to_s
 140     end
 141     class_eval(&block) if block
 142   end
 143 end
 144
 145 assert('Module#class_variable_defined?', '15.2.2.4.16') do
 146   class Test4ClassVariableDefined
 147     @@cv = 99
 148   end
 149
 150   assert_true Test4ClassVariableDefined.class_variable_defined?(:@@cv)
 151   assert_false Test4ClassVariableDefined.class_variable_defined?(:@@noexisting)
 152   assert_raise(NameError) { Test4ClassVariableDefined.class_variable_defined?("@@2") }
 153 end
 154
 155 assert('Module#class_variable_get', '15.2.2.4.17') do
 156   class Test4ClassVariableGet
 157     @@cv = 99
 158   end
 159
 160   assert_equal 99, Test4ClassVariableGet.class_variable_get(:@@cv)
 161   assert_raise(NameError) { Test4ClassVariableGet.class_variable_get(:@@a) }
 162   %w[@@a? @@! @a a].each do |n|
 163     assert_raise(NameError) { Test4ClassVariableGet.class_variable_get(n) }
 164   end
 165 end
 166
 167 assert('Module#class_variable_set', '15.2.2.4.18') do
 168   class Test4ClassVariableSet
 169     @@foo = 100
 170     def foo
 171       @@foo
 172     end
 173   end
 174
 175   assert_equal 99, Test4ClassVariableSet.class_variable_set(:@@cv, 99)
 176   assert_equal 101, Test4ClassVariableSet.class_variable_set(:@@foo, 101)
 177   assert_true Test4ClassVariableSet.class_variables.include? :@@cv
 178   assert_equal 99, Test4ClassVariableSet.class_variable_get(:@@cv)
 179   assert_equal 101, Test4ClassVariableSet.new.foo
 180   %w[@@ @@1 @@x= @x @ x 1].each do |n|
 181     assert_raise(NameError) { Test4ClassVariableSet.class_variable_set(n, 1) }
 182   end
 183 end
 184
 185 assert('Module#class_variables', '15.2.2.4.19') do
 186   class Test4ClassVariables1
 187     @@var1 = 1
 188   end
 189   class Test4ClassVariables2 < Test4ClassVariables1
 190     @@var2 = 2
 191   end
 192
 193   assert_equal [:@@var1], Test4ClassVariables1.class_variables
 194   assert_equal [:@@var2, :@@var1], Test4ClassVariables2.class_variables
 195 end
 196
 197 assert('Module#constants', '15.2.2.4.24') do
 198   $n = []
 199   module TestA
 200     C = 1
 201   end
 202   class TestB
 203     include TestA
 204     C2 = 1
 205     $n = constants.sort
 206   end
 207
 208   assert_equal [ :C ], TestA.constants
 209   assert_equal [ :C, :C2 ], $n
 210 end
 211
 212 assert('Module#included_modules', '15.2.2.4.30') do
 213   module Test4includedModules
 214   end
 215   module Test4includedModules2
 216     include Test4includedModules
 217   end
 218   r = Test4includedModules2.included_modules
 219
 220   assert_equal Array, r.class
 221   assert_true r.include?(Test4includedModules)
 222 end
 223
 224 assert('Module#instance_methods', '15.2.2.4.33') do
 225   module Test4InstanceMethodsA
 226     def method1()  end
 227   end
 228   class Test4InstanceMethodsB
 229     def method2()  end
 230   end
 231   class Test4InstanceMethodsC < Test4InstanceMethodsB
 232     def method3()  end
 233   end
 234
 235   r = Test4InstanceMethodsC.instance_methods(true)
 236
 237   assert_equal [:method1], Test4InstanceMethodsA.instance_methods
 238   assert_equal [:method2], Test4InstanceMethodsB.instance_methods(false)
 239   assert_equal [:method3], Test4InstanceMethodsC.instance_methods(false)
 240   assert_equal Array, r.class
 241   assert_true r.include?(:method3)
 242   assert_true r.include?(:method2)
 243 end
 244
 245 assert 'Module#prepend #instance_methods(false)' do
 246   bug6660 = '[ruby-dev:45863]'
 247   assert_equal([:m1], Class.new{ prepend Module.new; def m1; end }.instance_methods(false), bug6660)
 248   assert_equal([:m1], Class.new(Class.new{def m2;end}){ prepend Module.new; def m1; end }.instance_methods(false), bug6660)
 249 end
 250
 251 assert('Module#remove_class_variable', '15.2.2.4.39') do
 252   class Test4RemoveClassVariable
 253     @@cv = 99
 254   end
 255
 256   assert_equal 99, Test4RemoveClassVariable.remove_class_variable(:@@cv)
 257   assert_false Test4RemoveClassVariable.class_variables.include? :@@cv
 258   assert_raise(NameError) do
 259     Test4RemoveClassVariable.remove_class_variable(:@@cv)
 260   end
 261   assert_raise(NameError) do
 262     Test4RemoveClassVariable.remove_class_variable(:@v)
 263   end
 264 end
 265
 266 assert('Module#remove_method', '15.2.2.4.41') do
 267   module Test4RemoveMethod
 268     class Parent
 269       def hello
 270       end
 271      end
 272
 273      class Child < Parent
 274       def hello
 275       end
 276     end
 277   end
 278
 279   klass = Test4RemoveMethod::Child
 280   assert_same klass, klass.class_eval{ remove_method :hello }
 281   assert_true klass.instance_methods.include? :hello
 282   assert_false klass.instance_methods(false).include? :hello
 283 end
 284
 285 assert('Module.nesting', '15.2.2.2.2') do
 286   module Test4ModuleNesting
 287     module Test4ModuleNesting2
 288       assert_equal [Test4ModuleNesting2, Test4ModuleNesting],
 289                    Module.nesting
 290     end
 291   end
 292   module Test4ModuleNesting::Test4ModuleNesting2
 293     assert_equal [Test4ModuleNesting::Test4ModuleNesting2], Module.nesting
 294   end
 295 end
 296
 297 assert('Moduler#prepend + #instance_methods') do
 298   bug6655 = '[ruby-core:45915]'
 299   assert_equal(Object.instance_methods, Class.new {prepend Module.new}.instance_methods, bug6655)
 300 end
 301
 302 assert 'Module#prepend + #singleton_methods' do
 303   o = Object.new
 304   o.singleton_class.class_eval {prepend Module.new}
 305   assert_equal([], o.singleton_methods)
 306 end
 307
 308 assert 'Module#prepend + #remove_method' do
 309   c = Class.new do
 310     prepend Module.new { def foo; end }
 311   end
 312   assert_raise(NameError) do
 313     c.class_eval do
 314       remove_method(:foo)
 315     end
 316   end
 317   c.class_eval do
 318     def foo; end
 319   end
 320   removed = nil
 321   c.singleton_class.class_eval do
 322     define_method(:method_removed) {|id| removed = id}
 323   end
 324   assert_nothing_raised('[Bug #7843]') do
 325     c.class_eval do
 326       remove_method(:foo)
 327     end
 328   end
 329   assert_equal(:foo, removed)
 330 end
 331
 332 assert 'Module#prepend + #included_modules' do
 333   bug8025 = '[ruby-core:53158] [Bug #8025]'
 334   mixin = labeled_module("mixin")
 335   c = labeled_module("c") {prepend mixin}
 336   im = c.included_modules
 337   assert_not_include(im, c, bug8025)
 338   assert_include(im, mixin, bug8025)
 339   c1 = labeled_class("c1") {prepend mixin}
 340   c2 = labeled_class("c2", c1)
 341   im = c2.included_modules
 342   assert_not_include(im, c1, bug8025)
 343   assert_not_include(im, c2, bug8025)
 344   assert_include(im, mixin, bug8025)
 345 end
 346
 347 assert("remove_method doesn't segfault if the passed in argument isn't a symbol") do
 348   klass = Class.new
 349   assert_raise(TypeError) { klass.remove_method nil }
 350   assert_raise(TypeError) { klass.remove_method 123 }
 351   assert_raise(TypeError) { klass.remove_method 1.23 }
 352   assert_raise(NameError) { klass.remove_method "hello" }
 353   assert_raise(TypeError) { klass.remove_method Class.new }
 354 end
 355
 356 assert('alias_method and remove_method') do
 357   begin
 358     Fixnum.alias_method :to_s_, :to_s
 359     Fixnum.remove_method :to_s
 360
 361     assert_nothing_raised do
 362       # segfaults if mrb_cptr is used
 363       1.to_s
 364     end
 365   ensure
 366     Fixnum.alias_method :to_s, :to_s_
 367     Fixnum.remove_method :to_s_
 368   end
 369 end