/test/test_methods.rb
Ruby | 495 lines | 420 code | 64 blank | 11 comment | 0 complexity | f386845a50ac906eb3dadb2789f02fc3 MD5 | raw file
Possible License(s): GPL-3.0, JSON
- require 'test/unit'
- class TestMethods < Test::Unit::TestCase
- class A
- undef_method :id
- (class<<self;self;end).send(:undef_method,:id)
- end
- Adup = A.dup
- def test_undef_id
- assert_raise(NoMethodError) { A.id }
- assert_raise(NoMethodError) { A.new.id }
- assert_raise(NoMethodError) { Adup.id }
- assert_raise(NoMethodError) { Adup.new.id }
- end
-
- class Foo
- private
- def foo; end
- end
-
- def test_foo
- assert_raise(NoMethodError) {Foo.class_eval "new.foo"}
- begin
- Foo.class_eval "new.foo"
- rescue NoMethodError
- $!.to_s =~ /private/
- end
- end
- # JRUBY-2277
- def test_alias_method_calls_correct_method_added_with_sym
- $methods_added = []
- $singleton_methods_added = []
- c = Class.new do
- class << self
- def singleton_method_added(x) # will also add its own def!
- $singleton_methods_added << x
- end
- def method_added(x)
- $methods_added << x
- end
- def another_singleton
- end
- alias_method :yet_another_singleton, :another_singleton
- end
- def foo
- end
- def bar
- end
- alias_method :baz, :bar
- end
- expected_methods = [:foo, :bar, :baz]
- expected_singletons = [:singleton_method_added, :method_added, :another_singleton, :yet_another_singleton]
- assert_equal(expected_methods, $methods_added)
- assert_equal(expected_singletons, $singleton_methods_added)
- # test coercion of alias names to symbols
- name = Object.new
- def name.to_str
- "boo"
- end
- assert_nothing_raised { c.send("alias_method", name, "foo") }
- assert_equal(:boo, $methods_added.last)
- end
- end
- class TestMethodObjects < Test::Unit::TestCase
- # all testing return values are in the format
- # [receiver, origin, method_name]
- # origin = Class/Module's name (as Symbol) for instance methods,
- # Object for singleton methods
- class C
- def foo; [self, :C, :foo]; end
- def bar; [self, :C, :bar]; end
- # for simplicity on singleton representations,
- # let's assure #inspect = #to_s
- alias inspect to_s
- end
- class D < C
- def bar; [self, :D, :bar]; end
- def xyz; [self, :D, :xyz]; end
- end
- class E < D
- def qux; [self, :E, :qux]; end
- end
- class F < C
- def foo; [self, :F, :foo]; end
- end
- def test_method_call_equivalence
- c1 = C.new
- c2 = C.new
- c3 = C.new
- def c3.bar; [self, self, :bar]; end
- def c3.cor; [self, self, :cor]; end
- d1 = D.new
- d2 = D.new
- def d2.bar; [self, self, :bar]; end
- e1 = E.new
- e2 = E.new
- def e2.xyz; [self, self, :xyz]; end
- [c1, c2, c3].each do |c|
- assert_equal(c.foo, c.method(:foo).call)
- assert_equal(c.bar, c.method(:bar).call)
- end
- assert_equal(c3.cor, c3.method(:cor).call)
- [d1, d2].each do |d|
- assert_equal(d.foo, d.method(:foo).call)
- assert_equal(d.bar, d.method(:bar).call)
- assert_equal(d.xyz, d.method(:xyz).call)
- end
- [e1, e2].each do |e|
- assert_equal(e.foo, e.method(:foo).call)
- assert_equal(e.bar, e.method(:bar).call)
- assert_equal(e.xyz, e.method(:xyz).call)
- assert_equal(e.qux, e.method(:qux).call)
- end
- end
- def test_method_equivalence
- c1 = C.new
- c2 = C.new
- d1 = D.new
- e1 = E.new
- c1_foo1 = c1.method(:foo)
- c1_foo2 = c1.method(:foo)
- assert_equal(c1_foo1, c1_foo2)
- assert_equal(C.instance_method(:foo).bind(d1), d1.method(:foo))
- assert_equal(C.instance_method(:foo).bind(e1), e1.method(:foo))
- assert_equal(D.instance_method(:foo).bind(e1), e1.method(:foo))
- assert_equal(D.instance_method(:bar).bind(e1), e1.method(:bar))
- assert_not_equal(c1_foo1, c2.method(:foo))
- end
- def test_direct_method_to_s
- c1 = C.new
- c2 = C.new
- d1 = D.new
- assert_equal("#<Method: #{C}#foo>", c1.method(:foo).to_s)
- assert_equal("#<Method: #{C}#bar>", c1.method(:bar).to_s)
- assert_equal("#<Method: #{D}#bar>", d1.method(:bar).to_s)
- assert_equal("#<Method: #{D}#xyz>", d1.method(:xyz).to_s)
- # non-singleton methods of singleton-ized methods should still
- # be treated as direct methods
- def c2.foo; [self, self, :foo]; end
- assert_equal("#<Method: #{c2}.foo>", c2.method(:foo).to_s)
- assert_equal("#<Method: #{C}#bar>", c2.method(:bar).to_s)
- end
- def test_indirect_method_to_s
- d = D.new
- e = E.new
- assert_equal("#<Method: #{D}(#{C})#foo>", d.method(:foo).to_s)
- assert_equal("#<Method: #{E}(#{C})#foo>", e.method(:foo).to_s)
- assert_equal("#<Method: #{E}(#{D})#bar>", e.method(:bar).to_s)
- end
- def test_method_rebind
- c1 = C.new
- c2 = C.new
- c3 = C.new
- def c3.bar; [self, self, :bar]; end
- d1 = D.new
- c1_foo = c1.method(:foo)
- c2_foo = c2.method(:foo)
- c3_bar = c3.method(:bar)
- d1_foo = d1.method(:foo)
- d1_bar = d1.method(:bar)
- assert_equal(c1_foo, c1_foo.unbind.bind(c1))
- assert_equal(c2_foo, c1_foo.unbind.bind(c2))
- assert_equal(c1_foo.unbind, c2_foo.unbind.bind(c2).unbind)
- assert_equal(d1_foo, c1_foo.unbind.bind(d1))
- assert_equal(c2_foo, c1_foo.unbind.bind(c2))
- assert_equal(c2.foo, c1_foo.unbind.bind(c2).call)
- assert_raise(TypeError) { c3_bar.unbind.bind(c1) }
- assert_raise(TypeError) { d1_bar.unbind.bind(c1) }
- end
- def test_method_redefinition
- f = F.new
- f_bar1 = f.method(:bar)
- F.class_eval do
- def bar; [self, :F, :bar]; end
- end
- f_bar2 = f.method(:bar)
- assert_not_equal(f_bar1, f_bar2)
- assert_equal([f, :C, :bar], f_bar1.call)
- assert_equal([f, :F, :bar], f_bar2.call)
- assert_equal(f_bar1, C.instance_method(:bar).bind(f))
- end
- def test_unbound_method_equivalence
- c1 = C.new
- c2 = C.new
- def c2.bar; [self, self, :bar]; end
- d1 = D.new
- e1 = E.new
- e2 = E.new
- def e2.foo; [self, self, :foo]; end
- unbind = lambda { |o, m| o.method(m).unbind }
- c1_foo = unbind[c1, :foo]
- c1_foo2 = unbind[c1, :foo]
- e1_foo = unbind[e1, :foo]
- assert_equal(c1_foo, c1_foo2)
- assert_equal(c1_foo, unbind[c2, :foo])
- assert_equal(unbind[e1, :bar], unbind[e2, :bar])
- assert_equal(unbind[e1, :xyz], unbind[e2, :xyz])
- assert_equal(unbind[e1, :qux], unbind[e2, :qux])
- assert_not_equal(unbind[c1, :bar], unbind[c2, :bar])
- assert_not_equal(c1_foo, unbind[d1, :foo])
- assert_not_equal(e1_foo, c1_foo)
- assert_not_equal(e1_foo, unbind[d1, :foo])
- assert_not_equal(e1_foo, unbind[e2, :foo])
- assert_not_equal(c1_foo, unbind[e2, :foo])
- c__foo = C.instance_method(:foo)
- c__bar = C.instance_method(:bar)
- d__foo = D.instance_method(:foo)
- e__foo = E.instance_method(:foo)
- e__xyz = E.instance_method(:xyz)
- assert_not_equal(c__foo, d__foo)
- assert_not_equal(c__foo, e__foo)
- assert_equal(c1_foo, c__foo)
- assert_equal(e1_foo, e__foo)
- assert_not_equal(unbind[e2, :foo], e__foo)
- end
- def test_unbound_method_to_s
- c1 = C.new
- c2 = C.new
- d1 = D.new
- unbind = lambda { |o, m| o.method(m).unbind }
- c1_foo_u = unbind[c1, :foo]
- c2_foo_u = unbind[c2, :foo]
- d1_foo_u = unbind[d1, :foo]
- assert_equal(c1_foo_u.to_s, c2_foo_u.to_s)
- assert_equal("#<UnboundMethod: #{C}#foo>", c1_foo_u.to_s)
- assert_equal("#<UnboundMethod: #{D}(#{C})#foo>", d1_foo_u.to_s)
- e1 = E.new
- sing_e1 =
- class << e1
- def xyz; [self, self, :xyz]; end
- self
- end
- e1_foo_u = e1.method(:foo).unbind
- e1_bar_u = e1.method(:bar).unbind
- e1_xyz_u = e1.method(:xyz).unbind
- assert_equal("#<UnboundMethod: #{E}(#{C})#foo>", e1_foo_u.to_s)
- assert_equal("#<UnboundMethod: #{E}(#{D})#bar>", e1_bar_u.to_s)
- assert_equal("#<UnboundMethod: #{sing_e1}#xyz>", e1_xyz_u.to_s)
- end
- end
- class TestCaching < Test::Unit::TestCase
- module Foo
- def the_method
- $THE_METHOD = 'Foo'
- end
- end
- def setup
- $a = Class.new do
- def the_method
- $THE_METHOD = 'A'
- end
- end.new
- end
-
- def test_extend
- 40.times do
- $a.the_method
- assert_equal "A", $THE_METHOD
- end
- $a.extend Foo
- 40.times do
- $a.the_method
- assert_equal "Foo", $THE_METHOD
- end
- end
- def test_alias
- 40.times do
- $a.the_method
- assert_equal "A", $THE_METHOD
- end
- $a.class.class_eval do
- def the_bar_method
- $THE_METHOD = "Bar"
- end
- alias_method :the_method, :the_bar_method
- end
-
- $a.the_method
- assert_equal "Bar", $THE_METHOD
- end
- def test_direct
- a = Class.new do
- def foo ; false ; end
- end
- obj = a.new
- assert !obj.foo
- a.class_eval do
- def foo ; true ; end
- end
- assert obj.foo, "redefined method used"
- assert_raise(NoMethodError) { obj.bar }
- a.class_eval do
- def bar ; true ; end
- end
- assert obj.bar, "newly defined method used"
- end
-
- def test_parent
- a = Class.new do
- def foo ; false ; end
- end
- b = Class.new(a)
- obj = b.new
- assert !obj.foo
- a.class_eval do
- def foo ; true ; end
- end
- assert obj.foo, "redefined method used"
- assert_raise(NoMethodError) { obj.bar }
- a.class_eval do
- def bar ; true ; end
- end
- assert obj.bar, "newly defined method used"
- end
-
- def test_parent_shadowed
- a = Class.new do
- def foo ; :a ; end
- end
- b = Class.new(a) do
- def foo ; :b ; end
- end
- obj = b.new
- assert_equal :b, obj.foo
- a.class_eval do
- def foo ; false ; end
- end
- assert_equal :b, obj.foo, "shadowed method not used"
- end
-
- def test_intermediate_ancestor
- a = Class.new do
- def foo ; :a ; end
- end
- b = Class.new(a)
- c = Class.new(b)
- obj = c.new
- assert_equal :a, obj.foo
- b.class_eval do
- def foo ; :b ; end
- end
- assert_equal :b, obj.foo, "new method used"
- b.class_eval do
- def foo ; :b2 ; end
- end
- assert_equal :b2, obj.foo, "redefined method used"
- assert_raise(NoMethodError) { obj.bar }
- b.class_eval do
- def bar ; true ; end
- end
- assert obj.bar, "newly defined method used"
- end
- def test_intermediate_module
- a = Class.new do
- def foo ; :a ; end
- end
- m = Module.new do
- def foo ; :m ; end
- end
- b = Class.new(a)
- c = Class.new(b)
- obj = c.new
- assert_equal :a, obj.foo
- b.class_eval do
- include m
- end
- assert_equal :m, obj.foo, "method from included module used"
- m.module_eval do
- def foo ; :m2 ; end
- end
- assert_equal :m2, obj.foo, "redefined method used"
- assert_raise(NoMethodError) { obj.bar }
- m.module_eval do
- def bar ; true ; end
- end
- assert obj.bar, "newly defined method used"
- end
- def test_class_singleton_intermediate
- a = Class.new
- def a.foo ; :a ; end
- b = Class.new(a)
- c = Class.new(b)
- assert_equal :a, c.foo
- def b.foo ; :b ; end
- assert_equal :b, c.foo, "new shadowing method used"
- def b.foo ; :b2 ; end
- assert_equal :b2, c.foo, "redefined method used"
- assert_raise(NoMethodError) { c.bar }
- def b.bar ; true ; end
- assert c.bar, "newly defined method used"
- end
- def test_class_singleton_intermediate_extension
- a = Class.new
- def a.foo ; :a ; end
- b = Class.new(a)
- c = Class.new(b)
- m = Module.new do
- def foo ; :m ; end
- end
- assert_equal :a, c.foo
- b.extend m
- assert_equal :m, c.foo, "method from extended module used"
- m.module_eval do
- def foo ; :m2 ; end
- end
- assert_equal :m2, c.foo, "redefined method used"
- assert_raise(NoMethodError) { c.bar }
- m.module_eval do
- def bar ; true ; end
- end
- assert c.bar, "newly defined method used"
- end
- # JRUBY-2646
- def test_methods_with_various_arity_and_blocks
- a = Class.new do
- def m()
- yield
- end
- def m1(a)
- yield
- end
- def m2(a,b)
- yield
- end
- def m3(a,b,c)
- yield
- end
- def m4(a,b,c,d)
- yield
- end
- end
-
- obj = a.new
- assert_equal(5, obj.m { 5 })
- assert_equal(5, obj.m1(1) { 5 })
- assert_equal(5, obj.m2(1,2) { 5 })
- assert_equal(5, obj.m3(1,2,3) { 5 })
- assert_equal(5, obj.m4(1,2,3,4) { 5 })
- end
- end