2015-12-16 00:07:31 -05:00
|
|
|
# frozen_string_literal: false
|
2003-09-04 12:18:59 -04:00
|
|
|
require 'test/unit'
|
|
|
|
|
|
|
|
class TestDefined < Test::Unit::TestCase
|
|
|
|
class Foo
|
|
|
|
def foo
|
|
|
|
p :foo
|
|
|
|
end
|
|
|
|
protected :foo
|
|
|
|
def bar(f)
|
|
|
|
yield(defined?(self.foo))
|
|
|
|
yield(defined?(f.foo))
|
|
|
|
end
|
2007-11-22 20:46:44 -05:00
|
|
|
def baz(f)
|
|
|
|
end
|
2010-01-21 11:08:40 -05:00
|
|
|
attr_accessor :attr
|
|
|
|
def attrasgn_test
|
|
|
|
yield(defined?(self.attr = 1))
|
|
|
|
end
|
2003-09-04 12:18:59 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def defined_test
|
|
|
|
return !defined?(yield)
|
|
|
|
end
|
|
|
|
|
2020-05-07 17:05:46 -04:00
|
|
|
def test_defined_global_variable
|
2003-09-04 12:18:59 -04:00
|
|
|
$x = nil
|
|
|
|
|
|
|
|
assert(defined?($x)) # global variable
|
2003-09-05 11:15:43 -04:00
|
|
|
assert_equal('global-variable', defined?($x))# returns description
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
2003-09-05 11:15:43 -04:00
|
|
|
|
2020-04-22 09:21:11 -04:00
|
|
|
def test_defined_local_variable
|
2003-10-01 23:00:23 -04:00
|
|
|
assert_nil(defined?(foo)) # undefined
|
2003-09-04 12:18:59 -04:00
|
|
|
foo=5
|
|
|
|
assert(defined?(foo)) # local variable
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
2003-09-05 11:15:43 -04:00
|
|
|
|
2020-04-22 09:21:11 -04:00
|
|
|
def test_defined_constant
|
2003-10-01 23:00:23 -04:00
|
|
|
assert(defined?(Array)) # constant
|
|
|
|
assert(defined?(::Array)) # toplevel constant
|
|
|
|
assert(defined?(File::Constants)) # nested constant
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
|
|
|
|
2020-06-02 04:07:41 -04:00
|
|
|
def test_defined_public_method
|
2003-09-04 12:18:59 -04:00
|
|
|
assert(defined?(Object.new)) # method
|
2010-01-21 11:08:40 -05:00
|
|
|
assert(defined?(Object::new)) # method
|
2020-06-02 04:07:41 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_private_method
|
2003-09-04 12:18:59 -04:00
|
|
|
assert(!defined?(Object.print)) # private method
|
2020-06-02 04:07:41 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_operator
|
2003-09-04 12:18:59 -04:00
|
|
|
assert(defined?(1 == 2)) # operator expression
|
2020-06-02 04:07:41 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_protected_method
|
2003-09-04 12:18:59 -04:00
|
|
|
f = Foo.new
|
2007-11-22 20:46:44 -05:00
|
|
|
assert_nil(defined?(f.foo)) # protected method
|
2003-09-04 12:18:59 -04:00
|
|
|
f.bar(f) { |v| assert(v) }
|
2020-06-02 05:55:06 -04:00
|
|
|
f.bar(Class.new(Foo).new) { |v| assert(v, "inherited protected method") }
|
2020-06-02 04:07:41 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_undefined_method
|
|
|
|
f = Foo.new
|
2007-11-22 20:46:44 -05:00
|
|
|
assert_nil(defined?(f.quux)) # undefined method
|
2020-06-02 04:07:41 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_undefined_argument
|
|
|
|
f = Foo.new
|
2007-11-22 20:46:44 -05:00
|
|
|
assert_nil(defined?(f.baz(x))) # undefined argument
|
|
|
|
x = 0
|
|
|
|
assert(defined?(f.baz(x)))
|
|
|
|
assert_nil(defined?(f.quux(x)))
|
|
|
|
assert(defined?(print(x)))
|
|
|
|
assert_nil(defined?(quux(x)))
|
2020-06-02 04:07:41 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_attrasgn
|
|
|
|
f = Foo.new
|
2010-01-21 11:08:40 -05:00
|
|
|
assert(defined?(f.attr = 1))
|
|
|
|
f.attrasgn_test { |v| assert(v) }
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
2003-09-05 11:15:43 -04:00
|
|
|
|
2020-04-22 20:43:30 -04:00
|
|
|
def test_defined_undef
|
|
|
|
x = Object.new
|
|
|
|
def x.foo; end
|
|
|
|
assert(defined?(x.foo))
|
|
|
|
x.instance_eval {undef :foo}
|
|
|
|
assert(!defined?(x.foo), "undefed method should not be defined?")
|
|
|
|
end
|
|
|
|
|
2020-04-22 09:21:11 -04:00
|
|
|
def test_defined_yield
|
2003-09-04 12:18:59 -04:00
|
|
|
assert(defined_test) # not iterator
|
2007-11-22 20:46:44 -05:00
|
|
|
assert(!defined_test{}) # called as iterator
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
2007-11-26 23:43:54 -05:00
|
|
|
|
2020-04-22 09:21:11 -04:00
|
|
|
def test_defined_matchdata
|
2007-11-26 23:43:54 -05:00
|
|
|
/a/ =~ ''
|
|
|
|
assert_equal nil, defined?($&)
|
|
|
|
assert_equal nil, defined?($`)
|
|
|
|
assert_equal nil, defined?($')
|
|
|
|
assert_equal nil, defined?($+)
|
|
|
|
assert_equal nil, defined?($1)
|
|
|
|
assert_equal nil, defined?($2)
|
|
|
|
/a/ =~ 'a'
|
|
|
|
assert_equal 'global-variable', defined?($&)
|
|
|
|
assert_equal 'global-variable', defined?($`)
|
2011-03-24 10:03:45 -04:00
|
|
|
assert_equal 'global-variable', defined?($') # '
|
2007-11-26 23:43:54 -05:00
|
|
|
assert_equal nil, defined?($+)
|
|
|
|
assert_equal nil, defined?($1)
|
|
|
|
assert_equal nil, defined?($2)
|
|
|
|
/(a)/ =~ 'a'
|
|
|
|
assert_equal 'global-variable', defined?($&)
|
|
|
|
assert_equal 'global-variable', defined?($`)
|
2011-03-24 10:03:45 -04:00
|
|
|
assert_equal 'global-variable', defined?($') # '
|
2007-11-26 23:43:54 -05:00
|
|
|
assert_equal 'global-variable', defined?($+)
|
|
|
|
assert_equal 'global-variable', defined?($1)
|
|
|
|
assert_equal nil, defined?($2)
|
|
|
|
/(a)b/ =~ 'ab'
|
|
|
|
assert_equal 'global-variable', defined?($&)
|
|
|
|
assert_equal 'global-variable', defined?($`)
|
2011-03-24 10:03:45 -04:00
|
|
|
assert_equal 'global-variable', defined?($') # '
|
2007-11-26 23:43:54 -05:00
|
|
|
assert_equal 'global-variable', defined?($+)
|
|
|
|
assert_equal 'global-variable', defined?($1)
|
|
|
|
assert_equal nil, defined?($2)
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
2012-09-24 19:17:59 -04:00
|
|
|
|
2020-04-22 09:21:11 -04:00
|
|
|
def test_defined_literal
|
2012-09-24 19:17:59 -04:00
|
|
|
assert_equal("nil", defined?(nil))
|
|
|
|
assert_equal("true", defined?(true))
|
|
|
|
assert_equal("false", defined?(false))
|
|
|
|
assert_equal("expression", defined?(1))
|
2020-04-22 09:21:11 -04:00
|
|
|
end
|
2013-04-05 13:30:42 -04:00
|
|
|
|
2020-04-22 09:21:11 -04:00
|
|
|
def test_defined_empty_paren_expr
|
2013-04-05 13:30:42 -04:00
|
|
|
bug8224 = '[ruby-core:54024] [Bug #8224]'
|
|
|
|
(1..3).each do |level|
|
|
|
|
expr = "("*level+")"*level
|
|
|
|
assert_equal("nil", eval("defined? #{expr}"), "#{bug8224} defined? #{expr}")
|
|
|
|
assert_equal("nil", eval("defined?(#{expr})"), "#{bug8224} defined?(#{expr})")
|
|
|
|
end
|
2003-09-04 12:18:59 -04:00
|
|
|
end
|
2011-03-24 10:05:45 -04:00
|
|
|
|
2017-08-22 09:21:18 -04:00
|
|
|
def test_defined_empty_paren_arg
|
|
|
|
assert_nil(defined?(p () + 1))
|
|
|
|
end
|
|
|
|
|
2012-09-24 04:36:53 -04:00
|
|
|
def test_defined_impl_specific
|
|
|
|
feature7035 = '[ruby-core:47558]' # not spec
|
2012-09-24 08:10:51 -04:00
|
|
|
assert_predicate(defined?(Foo), :frozen?, feature7035)
|
2012-09-24 04:36:53 -04:00
|
|
|
assert_same(defined?(Foo), defined?(Array), feature7035)
|
|
|
|
end
|
|
|
|
|
2011-03-30 01:38:50 -04:00
|
|
|
class TestAutoloadedSuperclass
|
|
|
|
autoload :A, "a"
|
|
|
|
end
|
|
|
|
|
|
|
|
class TestAutoloadedSubclass < TestAutoloadedSuperclass
|
|
|
|
def a?
|
|
|
|
defined?(A)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-03-24 10:05:45 -04:00
|
|
|
def test_autoloaded_subclass
|
|
|
|
bug = "[ruby-core:35509]"
|
|
|
|
|
2011-03-30 01:38:50 -04:00
|
|
|
x = TestAutoloadedSuperclass.new
|
2011-03-24 10:05:45 -04:00
|
|
|
class << x
|
|
|
|
def a?; defined?(A); end
|
|
|
|
end
|
|
|
|
assert_equal("constant", x.a?, bug)
|
|
|
|
|
2011-03-30 01:38:50 -04:00
|
|
|
assert_equal("constant", TestAutoloadedSubclass.new.a?, bug)
|
|
|
|
end
|
|
|
|
|
|
|
|
class TestAutoloadedNoload
|
|
|
|
autoload :A, "a"
|
|
|
|
def a?
|
|
|
|
defined?(A)
|
2011-03-24 10:05:45 -04:00
|
|
|
end
|
2012-02-10 22:04:23 -05:00
|
|
|
def b?
|
|
|
|
defined?(A::B)
|
|
|
|
end
|
2011-03-24 10:05:45 -04:00
|
|
|
end
|
2011-03-24 10:06:31 -04:00
|
|
|
|
|
|
|
def test_autoloaded_noload
|
2011-03-24 10:41:17 -04:00
|
|
|
loaded = $".dup
|
|
|
|
$".clear
|
2012-02-10 22:04:23 -05:00
|
|
|
loadpath = $:.dup
|
|
|
|
$:.clear
|
2011-03-30 01:38:50 -04:00
|
|
|
x = TestAutoloadedNoload.new
|
2011-03-24 10:06:31 -04:00
|
|
|
assert_equal("constant", x.a?)
|
2012-02-10 22:04:23 -05:00
|
|
|
assert_nil(x.b?)
|
2011-03-24 10:41:17 -04:00
|
|
|
assert_equal([], $")
|
|
|
|
ensure
|
|
|
|
$".replace(loaded)
|
2012-02-10 22:04:23 -05:00
|
|
|
$:.replace(loadpath)
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_exception
|
|
|
|
bug5786 = '[ruby-dev:45021]'
|
|
|
|
assert_nil(defined?(raise("[Bug#5786]")::A), bug5786)
|
2011-03-24 10:06:31 -04:00
|
|
|
end
|
2012-07-11 16:11:45 -04:00
|
|
|
|
|
|
|
def test_define_method
|
|
|
|
bug6644 = '[ruby-core:45831]'
|
|
|
|
a = Class.new do
|
|
|
|
def self.def_f!;
|
|
|
|
singleton_class.send(:define_method, :f) { defined? super }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
aa = Class.new(a)
|
|
|
|
a.def_f!
|
|
|
|
assert_nil(a.f)
|
|
|
|
assert_nil(aa.f)
|
|
|
|
aa.def_f!
|
|
|
|
assert_equal("super", aa.f, bug6644)
|
|
|
|
assert_nil(a.f, bug6644)
|
|
|
|
end
|
2012-08-05 22:34:36 -04:00
|
|
|
|
|
|
|
def test_super_in_included_method
|
|
|
|
c0 = Class.new do
|
|
|
|
def m
|
|
|
|
end
|
|
|
|
end
|
|
|
|
m1 = Module.new do
|
|
|
|
def m
|
|
|
|
defined?(super)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
c = Class.new(c0) do include m1
|
|
|
|
def m
|
|
|
|
super
|
|
|
|
end
|
|
|
|
end
|
|
|
|
assert_equal("super", c.new.m)
|
|
|
|
end
|
2013-05-05 03:29:44 -04:00
|
|
|
|
|
|
|
def test_super_in_block
|
|
|
|
bug8367 = '[ruby-core:54769] [Bug #8367]'
|
|
|
|
c = Class.new do
|
|
|
|
def x; end
|
|
|
|
end
|
|
|
|
|
|
|
|
m = Module.new do
|
|
|
|
def b; yield; end
|
|
|
|
def x; b {return defined?(super)}; end
|
|
|
|
end
|
|
|
|
|
|
|
|
o = c.new
|
|
|
|
o.extend(m)
|
2014-03-04 08:55:24 -05:00
|
|
|
assert_equal("super", o.x, bug8367)
|
2013-05-05 03:29:44 -04:00
|
|
|
end
|
2013-05-05 06:02:41 -04:00
|
|
|
|
|
|
|
def test_super_toplevel
|
|
|
|
assert_separately([], "assert_nil(defined?(super))")
|
|
|
|
end
|
2015-06-02 15:36:43 -04:00
|
|
|
|
|
|
|
class ExampleRespondToMissing
|
|
|
|
attr_reader :called
|
|
|
|
|
|
|
|
def initialize
|
|
|
|
@called = false
|
|
|
|
end
|
|
|
|
|
|
|
|
def respond_to_missing? *args
|
|
|
|
@called = true
|
|
|
|
false
|
|
|
|
end
|
|
|
|
|
|
|
|
def existing_method
|
|
|
|
end
|
2015-06-02 15:49:22 -04:00
|
|
|
|
|
|
|
def func_defined_existing_func
|
|
|
|
defined?(existing_method())
|
|
|
|
end
|
|
|
|
|
|
|
|
def func_defined_non_existing_func
|
|
|
|
defined?(non_existing_method())
|
|
|
|
end
|
2015-06-02 15:36:43 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_method_by_respond_to_missing
|
|
|
|
bug_11211 = '[Bug #11211]'
|
|
|
|
obj = ExampleRespondToMissing.new
|
|
|
|
assert_equal("method", defined?(obj.existing_method), bug_11211)
|
|
|
|
assert_equal(false, obj.called, bug_11211)
|
|
|
|
assert_equal(nil, defined?(obj.non_existing_method), bug_11211)
|
|
|
|
assert_equal(true, obj.called, bug_11211)
|
2015-06-02 15:49:22 -04:00
|
|
|
|
|
|
|
bug_11212 = '[Bug #11212]'
|
|
|
|
obj = ExampleRespondToMissing.new
|
|
|
|
assert_equal("method", obj.func_defined_existing_func, bug_11212)
|
|
|
|
assert_equal(false, obj.called, bug_11212)
|
|
|
|
assert_equal(nil, obj.func_defined_non_existing_func, bug_11212)
|
|
|
|
assert_equal(true, obj.called, bug_11212)
|
2015-06-02 15:36:43 -04:00
|
|
|
end
|
2018-01-27 01:12:09 -05:00
|
|
|
|
|
|
|
def test_top_level_constant_not_defined
|
|
|
|
assert_nil(defined?(TestDefined::Object))
|
|
|
|
end
|
2020-06-03 10:05:55 -04:00
|
|
|
|
|
|
|
class RefinedClass
|
|
|
|
end
|
|
|
|
|
|
|
|
module RefiningModule
|
|
|
|
refine RefinedClass do
|
|
|
|
def pub
|
|
|
|
end
|
2020-06-03 10:06:06 -04:00
|
|
|
|
|
|
|
private
|
|
|
|
|
|
|
|
def priv
|
|
|
|
end
|
2020-06-03 10:05:55 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.call_without_using(x = RefinedClass.new)
|
|
|
|
defined?(x.pub)
|
|
|
|
end
|
|
|
|
|
2020-06-03 10:06:06 -04:00
|
|
|
def self.vcall_without_using(x = RefinedClass.new)
|
|
|
|
x.instance_eval {defined?(priv)}
|
|
|
|
end
|
|
|
|
|
2020-06-03 10:05:55 -04:00
|
|
|
using self
|
|
|
|
|
|
|
|
def self.call_with_using(x = RefinedClass.new)
|
|
|
|
defined?(x.pub)
|
|
|
|
end
|
2020-06-03 10:06:06 -04:00
|
|
|
|
|
|
|
def self.vcall_with_using(x = RefinedClass.new)
|
|
|
|
x.instance_eval {defined?(priv)}
|
|
|
|
end
|
2020-06-03 10:05:55 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_defined_refined_call_without_using
|
|
|
|
assert(!RefiningModule.call_without_using, "refined public method without using")
|
|
|
|
end
|
|
|
|
|
2020-06-03 10:06:06 -04:00
|
|
|
def test_defined_refined_vcall_without_using
|
|
|
|
assert(!RefiningModule.vcall_without_using, "refined private method without using")
|
|
|
|
end
|
|
|
|
|
2020-06-03 10:05:55 -04:00
|
|
|
def test_defined_refined_call_with_using
|
|
|
|
assert(RefiningModule.call_with_using, "refined public method with using")
|
|
|
|
end
|
2020-06-03 10:06:06 -04:00
|
|
|
|
|
|
|
def test_defined_refined_vcall_with_using
|
|
|
|
assert(RefiningModule.vcall_with_using, "refined private method with using")
|
|
|
|
end
|
2003-09-04 12:18:59 -04:00
|
|
|
end
|