/test/ruby/test_module.rb
Ruby | 2622 lines | 2264 code | 346 blank | 12 comment | 10 complexity | 3869d58833ed1449ebfb9a9f408e42e7 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause, AGPL-3.0
Large files files are truncated, but you can click here to view the full file
- # frozen_string_literal: false
- require 'test/unit'
- require 'pp'
- $m0 = Module.nesting
- class TestModule < Test::Unit::TestCase
- def _wrap_assertion
- yield
- end
- def assert_method_defined?(klass, mid, message="")
- message = build_message(message, "#{klass}\##{mid} expected to be defined.")
- _wrap_assertion do
- klass.method_defined?(mid) or
- raise Test::Unit::AssertionFailedError, message, caller(3)
- end
- end
- def assert_method_not_defined?(klass, mid, message="")
- message = build_message(message, "#{klass}\##{mid} expected to not be defined.")
- _wrap_assertion do
- klass.method_defined?(mid) and
- raise Test::Unit::AssertionFailedError, message, caller(3)
- end
- end
- def setup
- @verbose = $VERBOSE
- $VERBOSE = nil
- @deprecated = Warning[:deprecated]
- Warning[:deprecated] = true
- end
- def teardown
- $VERBOSE = @verbose
- Warning[:deprecated] = @deprecated
- end
- def test_LT_0
- assert_equal true, String < Object
- assert_equal false, Object < String
- assert_nil String < Array
- assert_equal true, Array < Enumerable
- assert_equal false, Enumerable < Array
- assert_nil Proc < Comparable
- assert_nil Comparable < Proc
- end
- def test_GT_0
- assert_equal false, String > Object
- assert_equal true, Object > String
- assert_nil String > Array
- assert_equal false, Array > Enumerable
- assert_equal true, Enumerable > Array
- assert_nil Comparable > Proc
- assert_nil Proc > Comparable
- end
- def test_CMP_0
- assert_equal(-1, (String <=> Object))
- assert_equal 1, (Object <=> String)
- assert_nil(Array <=> String)
- end
- ExpectedException = NoMethodError
- # Support stuff
- module Mixin
- MIXIN = 1
- def mixin
- end
- end
- module User
- USER = 2
- include Mixin
- def user
- end
- def user2
- end
- protected :user2
- def user3
- end
- private :user3
- end
- OtherSetup = -> do
- remove_const :Other if defined? ::TestModule::Other
- module Other
- def other
- end
- end
- end
- class AClass
- def AClass.cm1
- "cm1"
- end
- def AClass.cm2
- cm1 + "cm2" + cm3
- end
- def AClass.cm3
- "cm3"
- end
- private_class_method :cm1, "cm3"
- def aClass
- :aClass
- end
- def aClass1
- :aClass1
- end
- def aClass2
- :aClass2
- end
- private :aClass1
- protected :aClass2
- end
- class BClass < AClass
- def bClass1
- :bClass1
- end
- private
- def bClass2
- :bClass2
- end
- protected
- def bClass3
- :bClass3
- end
- end
- class CClass < BClass
- def self.cClass
- end
- end
- MyClass = AClass.clone
- class MyClass
- public_class_method :cm1
- end
- # -----------------------------------------------------------
- def test_CMP # '<=>'
- assert_equal( 0, Mixin <=> Mixin)
- assert_equal(-1, User <=> Mixin)
- assert_equal( 1, Mixin <=> User)
- assert_equal( 0, Object <=> Object)
- assert_equal(-1, String <=> Object)
- assert_equal( 1, Object <=> String)
- end
- def test_GE # '>='
- assert_operator(Mixin, :>=, User)
- assert_operator(Mixin, :>=, Mixin)
- assert_not_operator(User, :>=, Mixin)
- assert_operator(Object, :>=, String)
- assert_operator(String, :>=, String)
- assert_not_operator(String, :>=, Object)
- end
- def test_GT # '>'
- assert_operator(Mixin, :>, User)
- assert_not_operator(Mixin, :>, Mixin)
- assert_not_operator(User, :>, Mixin)
- assert_operator(Object, :>, String)
- assert_not_operator(String, :>, String)
- assert_not_operator(String, :>, Object)
- end
- def test_LE # '<='
- assert_operator(User, :<=, Mixin)
- assert_operator(Mixin, :<=, Mixin)
- assert_not_operator(Mixin, :<=, User)
- assert_operator(String, :<=, Object)
- assert_operator(String, :<=, String)
- assert_not_operator(Object, :<=, String)
- end
- def test_LT # '<'
- assert_operator(User, :<, Mixin)
- assert_not_operator(Mixin, :<, Mixin)
- assert_not_operator(Mixin, :<, User)
- assert_operator(String, :<, Object)
- assert_not_operator(String, :<, String)
- assert_not_operator(Object, :<, String)
- end
- def test_VERY_EQUAL # '==='
- assert_operator(Object, :===, self)
- assert_operator(Test::Unit::TestCase, :===, self)
- assert_operator(TestModule, :===, self)
- assert_not_operator(String, :===, self)
- end
- def test_ancestors
- assert_equal([User, Mixin], User.ancestors)
- assert_equal([Mixin], Mixin.ancestors)
- ancestors = Object.ancestors
- mixins = ancestors - [Object, Kernel, BasicObject]
- mixins << JSON::Ext::Generator::GeneratorMethods::String if defined?(JSON::Ext::Generator::GeneratorMethods::String)
- assert_equal([Object, Kernel, BasicObject], ancestors - mixins)
- assert_equal([String, Comparable, Object, Kernel, BasicObject], String.ancestors - mixins)
- end
- CLASS_EVAL = 2
- @@class_eval = 'b'
- def test_class_eval
- OtherSetup.call
- Other.class_eval("CLASS_EVAL = 1")
- assert_equal(1, Other::CLASS_EVAL)
- assert_include(Other.constants, :CLASS_EVAL)
- assert_equal(2, Other.class_eval { CLASS_EVAL })
- Other.class_eval("@@class_eval = 'a'")
- assert_equal('a', Other.class_variable_get(:@@class_eval))
- assert_equal('b', Other.class_eval { @@class_eval })
- Other.class_eval do
- module_function
- def class_eval_test
- "foo"
- end
- end
- assert_equal("foo", Other.class_eval_test)
- assert_equal([Other], Other.class_eval { |*args| args })
- end
- def test_const_defined?
- assert_operator(Math, :const_defined?, :PI)
- assert_operator(Math, :const_defined?, "PI")
- assert_not_operator(Math, :const_defined?, :IP)
- assert_not_operator(Math, :const_defined?, "IP")
- end
- def each_bad_constants(m, &b)
- [
- "#<Class:0x7b8b718b>",
- ":Object",
- "",
- ":",
- ["String::", "[Bug #7573]"],
- "\u3042",
- "Name?",
- ].each do |name, msg|
- expected = "wrong constant name %s" % name
- msg = "#{msg}#{': ' if msg}wrong constant name #{name.dump}"
- assert_raise_with_message(NameError, expected, "#{msg} to #{m}") do
- yield name
- end
- end
- end
- def test_bad_constants_get
- each_bad_constants("get") {|name|
- Object.const_get name
- }
- end
- def test_bad_constants_defined
- each_bad_constants("defined?") {|name|
- Object.const_defined? name
- }
- end
- def test_leading_colons
- assert_equal Object, AClass.const_get('::Object')
- end
- def test_const_get
- assert_equal(Math::PI, Math.const_get("PI"))
- assert_equal(Math::PI, Math.const_get(:PI))
- n = Object.new
- def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "PI"; end
- def n.count; @count; end
- assert_equal(Math::PI, Math.const_get(n))
- assert_equal(1, n.count)
- end
- def test_nested_get
- OtherSetup.call
- assert_equal Other, Object.const_get([self.class, 'Other'].join('::'))
- assert_equal User::USER, self.class.const_get([User, 'USER'].join('::'))
- assert_raise(NameError) {
- Object.const_get([self.class.name, 'String'].join('::'))
- }
- end
- def test_nested_get_symbol
- OtherSetup.call
- const = [self.class, Other].join('::').to_sym
- assert_raise(NameError) {Object.const_get(const)}
- const = [User, 'USER'].join('::').to_sym
- assert_raise(NameError) {self.class.const_get(const)}
- end
- def test_nested_get_const_missing
- classes = []
- klass = Class.new {
- define_singleton_method(:const_missing) { |name|
- classes << name
- klass
- }
- }
- klass.const_get("Foo::Bar::Baz")
- assert_equal [:Foo, :Bar, :Baz], classes
- end
- def test_nested_get_bad_class
- assert_raise(TypeError) do
- self.class.const_get([User, 'USER', 'Foo'].join('::'))
- end
- end
- def test_nested_defined
- OtherSetup.call
- assert_send([Object, :const_defined?, [self.class.name, 'Other'].join('::')])
- assert_send([self.class, :const_defined?, 'User::USER'])
- assert_not_send([self.class, :const_defined?, 'User::Foo'])
- assert_not_send([Object, :const_defined?, [self.class.name, 'String'].join('::')])
- end
- def test_nested_defined_symbol
- OtherSetup.call
- const = [self.class, Other].join('::').to_sym
- assert_raise(NameError) {Object.const_defined?(const)}
- const = [User, 'USER'].join('::').to_sym
- assert_raise(NameError) {self.class.const_defined?(const)}
- end
- def test_nested_defined_inheritance
- assert_send([Object, :const_defined?, [self.class.name, 'User', 'MIXIN'].join('::')])
- assert_send([self.class, :const_defined?, 'User::MIXIN'])
- assert_send([Object, :const_defined?, 'File::SEEK_SET'])
- # const_defined? with `false`
- assert_not_send([Object, :const_defined?, [self.class.name, 'User', 'MIXIN'].join('::'), false])
- assert_not_send([self.class, :const_defined?, 'User::MIXIN', false])
- assert_not_send([Object, :const_defined?, 'File::SEEK_SET', false])
- end
- def test_nested_defined_bad_class
- assert_raise(TypeError) do
- self.class.const_defined?('User::USER::Foo')
- end
- end
- def test_const_set
- OtherSetup.call
- assert_not_operator(Other, :const_defined?, :KOALA)
- Other.const_set(:KOALA, 99)
- assert_operator(Other, :const_defined?, :KOALA)
- assert_equal(99, Other::KOALA)
- Other.const_set("WOMBAT", "Hi")
- assert_equal("Hi", Other::WOMBAT)
- n = Object.new
- def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "HOGE"; end
- def n.count; @count; end
- def n.count=(v); @count=v; end
- assert_not_operator(Other, :const_defined?, :HOGE)
- Other.const_set(n, 999)
- assert_equal(1, n.count)
- n.count = 0
- assert_equal(999, Other.const_get(n))
- assert_equal(1, n.count)
- n.count = 0
- assert_equal(true, Other.const_defined?(n))
- assert_equal(1, n.count)
- end
- def test_constants
- assert_equal([:MIXIN], Mixin.constants)
- assert_equal([:MIXIN, :USER], User.constants.sort)
- end
- def test_self_initialize_copy
- bug9535 = '[ruby-dev:47989] [Bug #9535]'
- m = Module.new do
- def foo
- :ok
- end
- initialize_copy(self)
- end
- assert_equal(:ok, Object.new.extend(m).foo, bug9535)
- end
- def test_initialize_copy_empty
- bug9813 = '[ruby-dev:48182] [Bug #9813]'
- m = Module.new do
- def x
- end
- const_set(:X, 1)
- @x = 2
- end
- assert_equal([:x], m.instance_methods)
- assert_equal([:@x], m.instance_variables)
- assert_equal([:X], m.constants)
- m.module_eval do
- initialize_copy(Module.new)
- end
- assert_empty(m.instance_methods, bug9813)
- assert_empty(m.instance_variables, bug9813)
- assert_empty(m.constants, bug9813)
- end
- def test_dup
- OtherSetup.call
- bug6454 = '[ruby-core:45132]'
- a = Module.new
- Other.const_set :BUG6454, a
- b = a.dup
- Other.const_set :BUG6454_dup, b
- assert_equal "TestModule::Other::BUG6454_dup", b.inspect, bug6454
- end
- def test_dup_anonymous
- bug6454 = '[ruby-core:45132]'
- a = Module.new
- original = a.inspect
- b = a.dup
- assert_not_equal original, b.inspect, bug6454
- end
- def test_public_include
- assert_nothing_raised('#8846') do
- Module.new.include(Module.new { def foo; end }).instance_methods == [:foo]
- end
- end
- def test_include_toplevel
- assert_separately([], <<-EOS)
- Mod = Module.new {def foo; :include_foo end}
- TOPLEVEL_BINDING.eval('include Mod')
- assert_equal(:include_foo, TOPLEVEL_BINDING.eval('foo'))
- assert_equal([Object, Mod], Object.ancestors.slice(0, 2))
- EOS
- end
- def test_include_with_no_args
- assert_raise(ArgumentError) { Module.new { include } }
- end
- def test_include_into_module_already_included
- c = Class.new{def foo; [:c] end}
- modules = lambda do ||
- sub = Class.new(c){def foo; [:sc] + super end}
- [
- Module.new{def foo; [:m1] + super end},
- Module.new{def foo; [:m2] + super end},
- Module.new{def foo; [:m3] + super end},
- sub,
- sub.new
- ]
- end
- m1, m2, m3, sc, o = modules.call
- assert_equal([:sc, :c], o.foo)
- sc.include m1
- assert_equal([:sc, :m1, :c], o.foo)
- m1.include m2
- assert_equal([:sc, :m1, :m2, :c], o.foo)
- m2.include m3
- assert_equal([:sc, :m1, :m2, :m3, :c], o.foo)
- m1, m2, m3, sc, o = modules.call
- sc.prepend m1
- assert_equal([:m1, :sc, :c], o.foo)
- m1.include m2
- assert_equal([:m1, :m2, :sc, :c], o.foo)
- m2.include m3
- assert_equal([:m1, :m2, :m3, :sc, :c], o.foo)
- m1, m2, m3, sc, o = modules.call
- sc.include m2
- assert_equal([:sc, :m2, :c], o.foo)
- sc.prepend m1
- assert_equal([:m1, :sc, :m2, :c], o.foo)
- m1.include m2
- assert_equal([:m1, :sc, :m2, :c], o.foo)
- m1.include m3
- assert_equal([:m1, :m3, :sc, :m2, :c], o.foo)
- m1, m2, m3, sc, o = modules.call
- sc.include m3
- sc.include m2
- assert_equal([:sc, :m2, :m3, :c], o.foo)
- sc.prepend m1
- assert_equal([:m1, :sc, :m2, :m3, :c], o.foo)
- m1.include m2
- m1.include m3
- assert_equal([:m1, :sc, :m2, :m3, :c], o.foo)
- end
- def test_included_modules
- assert_equal([], Mixin.included_modules)
- assert_equal([Mixin], User.included_modules)
- mixins = Object.included_modules - [Kernel]
- mixins << JSON::Ext::Generator::GeneratorMethods::String if defined?(JSON::Ext::Generator::GeneratorMethods::String)
- assert_equal([Kernel], Object.included_modules - mixins)
- assert_equal([Comparable, Kernel], String.included_modules - mixins)
- end
- def test_instance_methods
- assert_equal([:user, :user2], User.instance_methods(false).sort)
- assert_equal([:user, :user2, :mixin].sort, User.instance_methods(true).sort)
- assert_equal([:mixin], Mixin.instance_methods)
- assert_equal([:mixin], Mixin.instance_methods(true))
- assert_equal([:cClass], (class << CClass; self; end).instance_methods(false))
- assert_equal([], (class << BClass; self; end).instance_methods(false))
- assert_equal([:cm2], (class << AClass; self; end).instance_methods(false))
- assert_equal([:aClass, :aClass2], AClass.instance_methods(false).sort)
- assert_equal([:aClass, :aClass2],
- (AClass.instance_methods(true) - Object.instance_methods(true)).sort)
- end
- def test_method_defined?
- [User, Class.new{include User}, Class.new{prepend User}].each do |klass|
- [[], [true]].each do |args|
- assert !klass.method_defined?(:wombat, *args)
- assert klass.method_defined?(:mixin, *args)
- assert klass.method_defined?(:user, *args)
- assert klass.method_defined?(:user2, *args)
- assert !klass.method_defined?(:user3, *args)
- assert !klass.method_defined?("wombat", *args)
- assert klass.method_defined?("mixin", *args)
- assert klass.method_defined?("user", *args)
- assert klass.method_defined?("user2", *args)
- assert !klass.method_defined?("user3", *args)
- end
- end
- end
- def test_method_defined_without_include_super
- assert User.method_defined?(:user, false)
- assert !User.method_defined?(:mixin, false)
- assert Mixin.method_defined?(:mixin, false)
- User.const_set(:FOO, c = Class.new)
- c.prepend(User)
- assert !c.method_defined?(:user, false)
- c.define_method(:user){}
- assert c.method_defined?(:user, false)
- assert !c.method_defined?(:mixin, false)
- c.define_method(:mixin){}
- assert c.method_defined?(:mixin, false)
- assert !c.method_defined?(:userx, false)
- c.define_method(:userx){}
- assert c.method_defined?(:userx, false)
- # cleanup
- User.class_eval do
- remove_const :FOO
- end
- end
- def module_exec_aux
- Proc.new do
- def dynamically_added_method_3; end
- end
- end
- def module_exec_aux_2(&block)
- User.module_exec(&block)
- end
- def test_module_exec
- User.module_exec do
- def dynamically_added_method_1; end
- end
- assert_method_defined?(User, :dynamically_added_method_1)
- block = Proc.new do
- def dynamically_added_method_2; end
- end
- User.module_exec(&block)
- assert_method_defined?(User, :dynamically_added_method_2)
- User.module_exec(&module_exec_aux)
- assert_method_defined?(User, :dynamically_added_method_3)
- module_exec_aux_2 do
- def dynamically_added_method_4; end
- end
- assert_method_defined?(User, :dynamically_added_method_4)
- # cleanup
- User.class_eval do
- remove_method :dynamically_added_method_1
- remove_method :dynamically_added_method_2
- remove_method :dynamically_added_method_3
- remove_method :dynamically_added_method_4
- end
- end
- def test_module_eval
- User.module_eval("MODULE_EVAL = 1")
- assert_equal(1, User::MODULE_EVAL)
- assert_include(User.constants, :MODULE_EVAL)
- User.instance_eval("remove_const(:MODULE_EVAL)")
- assert_not_include(User.constants, :MODULE_EVAL)
- end
- def test_name
- assert_equal("Integer", Integer.name)
- assert_equal("TestModule::Mixin", Mixin.name)
- assert_equal("TestModule::User", User.name)
- assert_predicate Integer.name, :frozen?
- assert_predicate Mixin.name, :frozen?
- assert_predicate User.name, :frozen?
- end
- def test_accidental_singleton_naming_with_module
- o = Object.new
- assert_nil(o.singleton_class.name)
- class << o
- module Hi; end
- end
- assert_nil(o.singleton_class.name)
- end
- def test_accidental_singleton_naming_with_class
- o = Object.new
- assert_nil(o.singleton_class.name)
- class << o
- class Hi; end
- end
- assert_nil(o.singleton_class.name)
- end
- def test_classpath
- m = Module.new
- n = Module.new
- m.const_set(:N, n)
- assert_nil(m.name)
- assert_nil(n.name)
- assert_equal([:N], m.constants)
- m.module_eval("module O end")
- assert_equal([:N, :O], m.constants.sort)
- m.module_eval("class C; end")
- assert_equal([:C, :N, :O], m.constants.sort)
- assert_nil(m::N.name)
- assert_match(/\A#<Module:.*>::O\z/, m::O.name)
- assert_match(/\A#<Module:.*>::C\z/, m::C.name)
- self.class.const_set(:M, m)
- prefix = self.class.name + "::M::"
- assert_equal(prefix+"N", m.const_get(:N).name)
- assert_equal(prefix+"O", m.const_get(:O).name)
- assert_equal(prefix+"C", m.const_get(:C).name)
- c = m.class_eval("Bug15891 = Class.new.freeze")
- assert_equal(prefix+"Bug15891", c.name)
- end
- def test_private_class_method
- assert_raise(ExpectedException) { AClass.cm1 }
- assert_raise(ExpectedException) { AClass.cm3 }
- assert_equal("cm1cm2cm3", AClass.cm2)
- end
- def test_private_instance_methods
- assert_equal([:aClass1], AClass.private_instance_methods(false))
- assert_equal([:bClass2], BClass.private_instance_methods(false))
- assert_equal([:aClass1, :bClass2],
- (BClass.private_instance_methods(true) -
- Object.private_instance_methods(true)).sort)
- end
- def test_protected_instance_methods
- assert_equal([:aClass2], AClass.protected_instance_methods)
- assert_equal([:bClass3], BClass.protected_instance_methods(false))
- assert_equal([:bClass3, :aClass2].sort,
- (BClass.protected_instance_methods(true) -
- Object.protected_instance_methods(true)).sort)
- end
- def test_public_class_method
- assert_equal("cm1", MyClass.cm1)
- assert_equal("cm1cm2cm3", MyClass.cm2)
- assert_raise(ExpectedException) { eval "MyClass.cm3" }
- end
- def test_public_instance_methods
- assert_equal([:aClass], AClass.public_instance_methods(false))
- assert_equal([:bClass1], BClass.public_instance_methods(false))
- end
- def test_s_constants
- c1 = Module.constants
- Object.module_eval "WALTER = 99"
- c2 = Module.constants
- assert_equal([:WALTER], c2 - c1)
- Object.class_eval do
- remove_const :WALTER
- end
- assert_equal([], Module.constants(true))
- assert_equal([], Module.constants(false))
- src = <<-INPUT
- ary = Module.constants
- module M
- WALTER = 99
- end
- class Module
- include M
- end
- p Module.constants - ary, Module.constants(true), Module.constants(false)
- INPUT
- assert_in_out_err([], src, %w([:M] [:WALTER] []), [])
- klass = Class.new do
- const_set(:X, 123)
- end
- assert_equal(false, klass.class_eval { Module.constants }.include?(:X))
- assert_equal(false, Complex.constants(false).include?(:compatible))
- end
- module M1
- $m1 = Module.nesting
- module M2
- $m2 = Module.nesting
- end
- end
- def test_s_nesting
- assert_equal([], $m0)
- assert_equal([TestModule::M1, TestModule], $m1)
- assert_equal([TestModule::M1::M2,
- TestModule::M1, TestModule], $m2)
- end
- def test_s_new
- m = Module.new
- assert_instance_of(Module, m)
- end
- def test_freeze
- m = Module.new do
- def self.baz; end
- def bar; end
- end
- m.freeze
- assert_raise(FrozenError) do
- m.module_eval do
- def foo; end
- end
- end
- assert_raise(FrozenError) do
- m.__send__ :private, :bar
- end
- assert_raise(FrozenError) do
- m.private_class_method :baz
- end
- end
- def test_attr_obsoleted_flag
- c = Class.new
- c.class_eval do
- def initialize
- @foo = :foo
- @bar = :bar
- end
- attr :foo, true
- attr :bar, false
- end
- o = c.new
- assert_equal(true, o.respond_to?(:foo))
- assert_equal(true, o.respond_to?(:foo=))
- assert_equal(true, o.respond_to?(:bar))
- assert_equal(false, o.respond_to?(:bar=))
- end
- def test_attr_public_at_toplevel
- s = Object.new
- TOPLEVEL_BINDING.eval(<<-END).call(s.singleton_class)
- proc do |c|
- c.send(:attr_accessor, :x)
- c.send(:attr, :y)
- c.send(:attr_reader, :z)
- c.send(:attr_writer, :w)
- end
- END
- assert_nil s.x
- s.x = 1
- assert_equal 1, s.x
- assert_nil s.y
- s.instance_variable_set(:@y, 2)
- assert_equal 2, s.y
- assert_nil s.z
- s.instance_variable_set(:@z, 3)
- assert_equal 3, s.z
- s.w = 4
- assert_equal 4, s.instance_variable_get(:@w)
- end
- def test_const_get_evaled
- c1 = Class.new
- c2 = Class.new(c1)
- eval("c1::Foo = :foo")
- assert_equal(:foo, c1::Foo)
- assert_equal(:foo, c2::Foo)
- assert_equal(:foo, c2.const_get(:Foo))
- assert_raise(NameError) { c2.const_get(:Foo, false) }
- eval("c1::Foo = :foo")
- assert_raise(NameError) { c1::Bar }
- assert_raise(NameError) { c2::Bar }
- assert_raise(NameError) { c2.const_get(:Bar) }
- assert_raise(NameError) { c2.const_get(:Bar, false) }
- assert_raise(NameError) { c2.const_get("Bar", false) }
- assert_raise(NameError) { c2.const_get("BaR11", false) }
- assert_raise(NameError) { Object.const_get("BaR11", false) }
- c1.instance_eval do
- def const_missing(x)
- x
- end
- end
- assert_equal(:Bar, c1::Bar)
- assert_equal(:Bar, c2::Bar)
- assert_equal(:Bar, c2.const_get(:Bar))
- assert_equal(:Bar, c2.const_get(:Bar, false))
- assert_equal(:Bar, c2.const_get("Bar"))
- assert_equal(:Bar, c2.const_get("Bar", false))
- v = c2.const_get("Bar11", false)
- assert_equal("Bar11".to_sym, v)
- assert_raise(NameError) { c1.const_get(:foo) }
- end
- def test_const_set_invalid_name
- c1 = Class.new
- assert_raise_with_message(NameError, /foo/) { c1.const_set(:foo, :foo) }
- assert_raise_with_message(NameError, /bar/) { c1.const_set("bar", :foo) }
- assert_raise_with_message(TypeError, /1/) { c1.const_set(1, :foo) }
- assert_nothing_raised(NameError) { c1.const_set("X\u{3042}", :foo) }
- assert_raise(NameError) { c1.const_set("X\u{3042}".encode("utf-16be"), :foo) }
- assert_raise(NameError) { c1.const_set("X\u{3042}".encode("utf-16le"), :foo) }
- assert_raise(NameError) { c1.const_set("X\u{3042}".encode("utf-32be"), :foo) }
- assert_raise(NameError) { c1.const_set("X\u{3042}".encode("utf-32le"), :foo) }
- cx = EnvUtil.labeled_class("X\u{3042}")
- assert_raise_with_message(TypeError, /X\u{3042}/) { c1.const_set(cx, :foo) }
- end
- def test_const_get_invalid_name
- c1 = Class.new
- assert_raise(NameError) { c1.const_get(:foo) }
- bug5084 = '[ruby-dev:44200]'
- assert_raise(TypeError, bug5084) { c1.const_get(1) }
- end
- def test_const_defined_invalid_name
- c1 = Class.new
- assert_raise(NameError) { c1.const_defined?(:foo) }
- bug5084 = '[ruby-dev:44200]'
- assert_raise(TypeError, bug5084) { c1.const_defined?(1) }
- end
- def test_const_get_no_inherited
- bug3422 = '[ruby-core:30719]'
- assert_in_out_err([], <<-INPUT, %w[1 NameError A], [], bug3422)
- BasicObject::A = 1
- puts [true, false].map {|inh|
- begin
- Object.const_get(:A, inh)
- rescue NameError => e
- [e.class, e.name]
- end
- }
- INPUT
- end
- def test_const_get_inherited
- bug3423 = '[ruby-core:30720]'
- assert_in_out_err([], <<-INPUT, %w[NameError A NameError A], [], bug3423)
- module Foo; A = 1; end
- class Object; include Foo; end
- class Bar; include Foo; end
- puts [Object, Bar].map {|klass|
- begin
- klass.const_get(:A, false)
- rescue NameError => e
- [e.class, e.name]
- end
- }
- INPUT
- end
- def test_const_in_module
- bug3423 = '[ruby-core:37698]'
- assert_in_out_err([], <<-INPUT, %w[ok], [], bug3423)
- module LangModuleSpecInObject
- module LangModuleTop
- end
- end
- include LangModuleSpecInObject
- module LangModuleTop
- end
- puts "ok" if LangModuleSpecInObject::LangModuleTop == LangModuleTop
- INPUT
- bug5264 = '[ruby-core:39227]'
- assert_in_out_err([], <<-'INPUT', [], [], bug5264)
- class A
- class X; end
- end
- class B < A
- module X; end
- end
- INPUT
- end
- def test_class_variable_get
- c = Class.new
- c.class_eval('@@foo = :foo')
- assert_equal(:foo, c.class_variable_get(:@@foo))
- assert_raise(NameError) { c.class_variable_get(:@@bar) } # c.f. instance_variable_get
- assert_raise(NameError) { c.class_variable_get(:'@@') }
- assert_raise(NameError) { c.class_variable_get('@@') }
- assert_raise(NameError) { c.class_variable_get(:foo) }
- assert_raise(NameError) { c.class_variable_get("bar") }
- assert_raise(TypeError) { c.class_variable_get(1) }
- n = Object.new
- def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "@@foo"; end
- def n.count; @count; end
- assert_equal(:foo, c.class_variable_get(n))
- assert_equal(1, n.count)
- end
- def test_class_variable_set
- c = Class.new
- c.class_variable_set(:@@foo, :foo)
- assert_equal(:foo, c.class_eval('@@foo'))
- assert_raise(NameError) { c.class_variable_set(:'@@', 1) }
- assert_raise(NameError) { c.class_variable_set('@@', 1) }
- assert_raise(NameError) { c.class_variable_set(:foo, 1) }
- assert_raise(NameError) { c.class_variable_set("bar", 1) }
- assert_raise(TypeError) { c.class_variable_set(1, 1) }
- n = Object.new
- def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "@@foo"; end
- def n.count; @count; end
- c.class_variable_set(n, :bar)
- assert_equal(:bar, c.class_eval('@@foo'))
- assert_equal(1, n.count)
- end
- def test_class_variable_defined
- c = Class.new
- c.class_eval('@@foo = :foo')
- assert_equal(true, c.class_variable_defined?(:@@foo))
- assert_equal(false, c.class_variable_defined?(:@@bar))
- assert_raise(NameError) { c.class_variable_defined?(:'@@') }
- assert_raise(NameError) { c.class_variable_defined?('@@') }
- assert_raise(NameError) { c.class_variable_defined?(:foo) }
- assert_raise(NameError) { c.class_variable_defined?("bar") }
- assert_raise(TypeError) { c.class_variable_defined?(1) }
- n = Object.new
- def n.to_str; @count = defined?(@count) ? @count + 1 : 1; "@@foo"; end
- def n.count; @count; end
- assert_equal(true, c.class_variable_defined?(n))
- assert_equal(1, n.count)
- end
- def test_remove_class_variable
- c = Class.new
- c.class_eval('@@foo = :foo')
- c.class_eval { remove_class_variable(:@@foo) }
- assert_equal(false, c.class_variable_defined?(:@@foo))
- assert_raise(NameError) do
- c.class_eval { remove_class_variable(:@var) }
- end
- end
- def test_export_method
- m = Module.new
- assert_raise(NameError) do
- m.instance_eval { public(:foo) }
- end
- end
- def test_attr
- assert_in_out_err([], <<-INPUT, %w(nil))
- $VERBOSE = true
- c = Class.new
- c.instance_eval do
- private
- attr_reader :foo
- end
- o = c.new
- p(o.instance_eval { foo })
- INPUT
- c = Class.new
- assert_raise(NameError) do
- c.instance_eval { attr_reader :"." }
- end
- end
- def test_undef
- c = Class.new
- assert_raise(NameError) do
- c.instance_eval { undef_method(:foo) }
- end
- m = Module.new
- assert_raise(NameError) do
- m.instance_eval { undef_method(:foo) }
- end
- o = Object.new
- assert_raise(NameError) do
- class << o; self; end.instance_eval { undef_method(:foo) }
- end
- %w(object_id __send__ initialize).each do |n|
- assert_in_out_err([], <<-INPUT, [], %r"warning: undefining `#{n}' may cause serious problems$")
- $VERBOSE = false
- Class.new.instance_eval { undef_method(:#{n}) }
- INPUT
- end
- end
- def test_alias
- m = Module.new
- assert_raise(NameError) do
- m.class_eval { alias foo bar }
- end
- assert_in_out_err([], <<-INPUT, %w(2), /discarding old foo$/)
- $VERBOSE = true
- c = Class.new
- c.class_eval do
- def foo; 1; end
- def bar; 2; end
- end
- c.class_eval { alias foo bar }
- p c.new.foo
- INPUT
- end
- def test_mod_constants
- m = Module.new
- m.const_set(:Foo, :foo)
- assert_equal([:Foo], m.constants(true))
- assert_equal([:Foo], m.constants(false))
- m.instance_eval { remove_const(:Foo) }
- end
- class Bug9413
- class << self
- Foo = :foo
- end
- end
- def test_singleton_constants
- bug9413 = '[ruby-core:59763] [Bug #9413]'
- c = Bug9413.singleton_class
- assert_include(c.constants(true), :Foo, bug9413)
- assert_include(c.constants(false), :Foo, bug9413)
- end
- def test_frozen_module
- m = Module.new
- m.freeze
- assert_raise(FrozenError) do
- m.instance_eval { undef_method(:foo) }
- end
- end
- def test_frozen_class
- c = Class.new
- c.freeze
- assert_raise(FrozenError) do
- c.instance_eval { undef_method(:foo) }
- end
- end
- def test_frozen_singleton_class
- klass = Class.new
- o = klass.new
- c = class << o; self; end
- c.freeze
- assert_raise_with_message(FrozenError, /frozen/) do
- c.instance_eval { undef_method(:foo) }
- end
- klass.class_eval do
- def self.foo
- end
- end
- end
- def test_method_defined
- cl = Class.new
- def_methods = proc do
- def foo; end
- def bar; end
- def baz; end
- public :foo
- protected :bar
- private :baz
- end
- cl.class_eval(&def_methods)
- sc = Class.new(cl)
- mod = Module.new(&def_methods)
- only_prepend = Class.new{prepend(mod)}
- empty_prepend = cl.clone
- empty_prepend.prepend(Module.new)
- overlap_prepend = cl.clone
- overlap_prepend.prepend(mod)
- [[], [true], [false]].each do |args|
- [cl, sc, only_prepend, empty_prepend, overlap_prepend].each do |c|
- always_false = [sc, only_prepend].include?(c) && args == [false]
- assert_equal(always_false ? false : true, c.public_method_defined?(:foo, *args))
- assert_equal(always_false ? false : false, c.public_method_defined?(:bar, *args))
- assert_equal(always_false ? false : false, c.public_method_defined?(:baz, *args))
- # Test if string arguments are converted to symbols
- assert_equal(always_false ? false : true, c.public_method_defined?("foo", *args))
- assert_equal(always_false ? false : false, c.public_method_defined?("bar", *args))
- assert_equal(always_false ? false : false, c.public_method_defined?("baz", *args))
- assert_equal(always_false ? false : false, c.protected_method_defined?(:foo, *args))
- assert_equal(always_false ? false : true, c.protected_method_defined?(:bar, *args))
- assert_equal(always_false ? false : false, c.protected_method_defined?(:baz, *args))
- # Test if string arguments are converted to symbols
- assert_equal(always_false ? false : false, c.protected_method_defined?("foo", *args))
- assert_equal(always_false ? false : true, c.protected_method_defined?("bar", *args))
- assert_equal(always_false ? false : false, c.protected_method_defined?("baz", *args))
- assert_equal(always_false ? false : false, c.private_method_defined?(:foo, *args))
- assert_equal(always_false ? false : false, c.private_method_defined?(:bar, *args))
- assert_equal(always_false ? false : true, c.private_method_defined?(:baz, *args))
- # Test if string arguments are converted to symbols
- assert_equal(always_false ? false : false, c.private_method_defined?("foo", *args))
- assert_equal(always_false ? false : false, c.private_method_defined?("bar", *args))
- assert_equal(always_false ? false : true, c.private_method_defined?("baz", *args))
- end
- end
- end
- def test_top_public_private
- assert_in_out_err([], <<-INPUT, %w([:foo] [:bar]), [])
- private
- def foo; :foo; end
- public
- def bar; :bar; end
- p self.private_methods.grep(/^foo$|^bar$/)
- p self.methods.grep(/^foo$|^bar$/)
- INPUT
- end
- def test_append_features
- t = nil
- m = Module.new
- m.module_eval do
- def foo; :foo; end
- end
- class << m; self; end.class_eval do
- define_method(:append_features) do |mod|
- t = mod
- super(mod)
- end
- end
- m2 = Module.new
- m2.module_eval { include(m) }
- assert_equal(m2, t)
- o = Object.new
- o.extend(m2)
- assert_equal(true, o.respond_to?(:foo))
- end
- def test_append_features_raise
- m = Module.new
- m.module_eval do
- def foo; :foo; end
- end
- class << m; self; end.class_eval do
- define_method(:append_features) {|mod| raise }
- end
- m2 = Module.new
- assert_raise(RuntimeError) do
- m2.module_eval { include(m) }
- end
- o = Object.new
- o.extend(m2)
- assert_equal(false, o.respond_to?(:foo))
- end
- def test_append_features_type_error
- assert_raise(TypeError) do
- Module.new.instance_eval { append_features(1) }
- end
- end
- def test_included
- m = Module.new
- m.module_eval do
- def foo; :foo; end
- end
- class << m; self; end.class_eval do
- define_method(:included) {|mod| raise }
- end
- m2 = Module.new
- assert_raise(RuntimeError) do
- m2.module_eval { include(m) }
- end
- o = Object.new
- o.extend(m2)
- assert_equal(true, o.respond_to?(:foo))
- end
- def test_cyclic_include
- m1 = Module.new
- m2 = Module.new
- m1.instance_eval { include(m2) }
- assert_raise(ArgumentError) do
- m2.instance_eval { include(m1) }
- end
- end
- def test_include_p
- m = Module.new
- c1 = Class.new
- c1.instance_eval { include(m) }
- c2 = Class.new(c1)
- assert_equal(true, c1.include?(m))
- assert_equal(true, c2.include?(m))
- assert_equal(false, m.include?(m))
- end
- def test_send
- a = AClass.new
- assert_equal(:aClass, a.__send__(:aClass))
- assert_equal(:aClass1, a.__send__(:aClass1))
- assert_equal(:aClass2, a.__send__(:aClass2))
- b = BClass.new
- assert_equal(:aClass, b.__send__(:aClass))
- assert_equal(:aClass1, b.__send__(:aClass1))
- assert_equal(:aClass2, b.__send__(:aClass2))
- assert_equal(:bClass1, b.__send__(:bClass1))
- assert_equal(:bClass2, b.__send__(:bClass2))
- assert_equal(:bClass3, b.__send__(:bClass3))
- end
- def test_nonascii_name
- c = eval("class ::C\u{df}; self; end")
- assert_equal("C\u{df}", c.name, '[ruby-core:24600]')
- c = eval("class C\u{df}; self; end")
- assert_equal("TestModule::C\u{df}", c.name, '[ruby-core:24600]')
- c = Module.new.module_eval("class X\u{df} < Module; self; end")
- assert_match(/::X\u{df}:/, c.new.to_s)
- end
- def test_method_added
- memo = []
- mod = Module.new do
- mod = self
- (class << self ; self ; end).class_eval do
- define_method :method_added do |sym|
- memo << sym
- memo << mod.instance_methods(false)
- memo << (mod.instance_method(sym) rescue nil)
- end
- end
- def f
- end
- alias g f
- attr_reader :a
- attr_writer :a
- end
- assert_equal :f, memo.shift
- assert_equal [:f], memo.shift, '[ruby-core:25536]'
- assert_equal mod.instance_method(:f), memo.shift
- assert_equal :g, memo.shift
- assert_equal [:f, :g].sort, memo.shift.sort
- assert_equal mod.instance_method(:f), memo.shift
- assert_equal :a, memo.shift
- assert_equal [:f, :g, :a].sort, memo.shift.sort
- assert_equal mod.instance_method(:a), memo.shift
- assert_equal :a=, memo.shift
- assert_equal [:f, :g, :a, :a=].sort, memo.shift.sort
- assert_equal mod.instance_method(:a=), memo.shift
- end
- def test_method_undefined
- added = []
- undefed = []
- removed = []
- mod = Module.new do
- mod = self
- def f
- end
- (class << self ; self ; end).class_eval do
- define_method :method_added do |sym|
- added << sym
- end
- define_method :method_undefined do |sym|
- undefed << sym
- end
- define_method :method_removed do |sym|
- removed << sym
- end
- end
- end
- assert_method_defined?(mod, :f)
- mod.module_eval do
- undef :f
- end
- assert_equal [], added
- assert_equal [:f], undefed
- assert_equal [], removed
- end
- def test_method_removed
- added = []
- undefed = []
- removed = []
- mod = Module.new do
- mod = self
- def f
- end
- (class << self ; self ; end).class_eval do
- define_method :method_added do |sym|
- added << sym
- end
- define_method :method_undefined do |sym|
- undefed << sym
- end
- define_method :method_removed do |sym|
- removed << sym
- end
- end
- end
- assert_method_defined?(mod, :f)
- mod.module_eval do
- remove_method :f
- end
- assert_equal [], added
- assert_equal [], undefed
- assert_equal [:f], removed
- end
- def test_method_redefinition
- feature2155 = '[ruby-dev:39400]'
- line = __LINE__+4
- stderr = EnvUtil.verbose_warning do
- Module.new do
- def foo; end
- def foo; end
- end
- end
- assert_match(/:#{line}: warning: method redefined; discarding old foo/, stderr)
- assert_match(/:#{line-1}: warning: previous definition of foo/, stderr, feature2155)
- assert_warning '' do
- Module.new do
- def foo; end
- alias bar foo
- def foo; end
- end
- end
- assert_warning '' do
- Module.new do
- def foo; end
- alias bar foo
- alias bar foo
- end
- end
- line = __LINE__+4
- stderr = EnvUtil.verbose_warning do
- Module.new do
- define_method(:foo) do end
- def foo; end
- end
- end
- assert_match(/:#{line}: warning: method redefined; discarding old foo/, stderr)
- assert_match(/:#{line-1}: warning: previous definition of foo/, stderr, feature2155)
- assert_warning '' do
- Module.new do
- define_method(:foo) do end
- alias bar foo
- alias bar foo
- end
- end
- assert_warning('', '[ruby-dev:39397]') do
- Module.new do
- module_function
- def foo; end
- module_function :foo
- end
- end
- assert_warning '' do
- Module.new do
- def foo; end
- undef foo
- end
- end
- stderr = EnvUtil.verbose_warning do
- Module.new do
- def foo; end
- mod = self
- c = Class.new do
- include mod
- end
- c.new.foo
- def foo; end
- end
- end
- assert_match(/: warning: method redefined; discarding old foo/, stderr)
- assert_match(/: warning: previous definition of foo/, stderr)
- end
- def test_module_function_inside_method
- assert_warn(/calling module_function without arguments inside a method may not have the intended effect/, '[ruby-core:79751]') do
- Module.new do
- def self.foo
- module_function
- end
- foo
- end
- end
- end
- def test_protected_singleton_method
- klass = Class.new
- x = klass.new
- class << x
- protected
- def foo
- end
- end
- assert_raise(NoMethodError) do
- x.foo
- end
- klass.send(:define_method, :bar) do
- x.foo
- end
- assert_nothing_raised do
- x.bar
- end
- y = klass.new
- assert_raise(NoMethodError) do
- y.bar
- end
- end
- def test_uninitialized_toplevel_constant
- bug3123 = '[ruby-dev:40951]'
- e = assert_raise(NameError) {eval("Bug3123", TOPLEVEL_BINDING)}
- assert_not_match(/Object::/, e.message, bug3123)
- end
- def test_attr_inherited_visibility
- bug3406 = '[ruby-core:30638]'
- c = Class.new do
- class << self
- private
- def attr_accessor(*); super; end
- end
- attr_accessor :x
- end.new
- assert_nothing_raised(bug3406) {c.x = 1}
- assert_equal(1, c.x, bug3406)
- end
- def test_attr_writer_with_no_arguments
- bug8540 = "[ruby-core:55543]"
- c = Class.new do
- attr_writer :foo
- end
- assert_raise(ArgumentError, bug8540) { c.new.send :foo= }
- end
- def test_private_constant_in_class
- c = Class.new
- c.const_set(:FOO, "foo")
- assert_equal("foo", c::FOO)
- c.private_constant(:FOO)
- e = assert_raise(NameError) {c::FOO}
- assert_equal(c, e.receiver)
- assert_equal(:FOO, e.name)
- assert_equal("foo", c.class_eval("FOO"))
- assert_equal("foo", c.const_get("FOO"))
- $VERBOSE, verbose = nil, $VERBOSE
- c.const_set(:FOO, "foo")
- $VERBOSE = verbose
- e = assert_raise(NameError) {c::FOO}
- assert_equal(c, e.receiver)
- assert_equal(:FOO, e.name)
- e = assert_raise_with_message(NameError, /#{c}::FOO/) do
- Class.new(c)::FOO
- end
- assert_equal(c, e.receiver)
- assert_equal(:FOO, e.name)
- end
- def test_private_constant_in_module
- m = Module.new
- m.const_set(:FOO, "foo")
- assert_equal("foo", m::FOO)
- m.private_constant(:FOO)
- e = assert_raise(NameError) {m::FOO}
- assert_equal(m, e.receiver)
- assert_equal(:FOO, e.name)
- assert_equal("foo", m.class_eval("FOO"))
- assert_equal("foo", m.const_get("FOO"))
- $VERBOSE, verbose = nil, $VERBOSE
- m.const_set(:FOO, "foo")
- $VERBOSE = verbose
- e = assert_raise(NameError) {m::FOO}
- assert_equal(m, e.receiver)
- assert_equal(:FOO, e.name)
- e = assert_raise(NameError, /#{m}::FOO/) do
- Module.new {include m}::FOO
- end
- assert_equal(m, e.receiver)
- assert_equal(:FOO, e.name)
- e = assert_raise(NameError, /#{m}::FOO/) do
- Class.new {include m}::FOO
- end
- assert_equal(m, e.receiver)
- assert_equal(:FOO, e.name)
- end
- def test_private_constant2
- c = Class.new
- c.const_set(:FOO, "foo")
- c.const_set(:BAR, "bar")
- assert_equal("foo", c::FOO)
- assert_equal("bar", c::BAR)
- c.private_constant(:FOO, :BAR)
- assert_raise(NameError) { c::FOO }
- assert_raise(NameError) { c::BAR }
- assert_equal("foo", c.class_eval("FOO"))
- assert_equal("bar", c.class_eval("BAR"))
- end
- def test_private_constant_with_no_args
- assert_in_out_err([], <<-RUBY, [], ["-:3: warning: private_constant with no argument is just ignored"])
- $-w = true
- class X
- private_constant
- end
- RUBY
- end
- def test_private_constant_const_missing
- c = Class.new
- c.const_set(:FOO, "foo")
- c.private_constant(:FOO)
- class << c
- attr_reader :const_missing_arg
- def const_missing(name)
- @const_missing_arg = name
- name == :FOO ? const_get(:FOO) : super
- end
- end
- assert_equal("foo", c::FOO)
- assert_equal(:FOO, c.const_missing_arg)
- end
- class PrivateClass
- end
- private_constant :PrivateClass
- def test_define_module_under_private_constant
- assert_raise(NameError) do
- eval %q{class TestModule::PrivateClass; end}
- end
- assert_raise(NameError) do
- eval %q{module TestModule::PrivateClass::TestModule; end}
- end
- eval %q{class PrivateClass; end}
- eval %q{module PrivateClass::TestModule; end}
- assert_instance_of(Module, PrivateClass::TestModule)
- PrivateClass.class_eval { remove_const(:TestModule) }
- end
- def test_public_constant
- c = Class.new
- c.const_set(:FOO, "foo")
- assert_equal("foo", c::FOO)
- c.private_constant(:FOO)
- assert_raise(NameError) { c::FOO }
- assert_equal("foo", c.class_eval("FOO"))
- c.public_constant(:FOO)
- assert_equal("foo", c::FOO)
- end
- def test_deprecate_constant
- c = Class.new
- c.const_set(:FOO, "foo")
- c.deprecate_constant(:FOO)
- assert_warn(/deprecated/) {c::FOO}
- assert_warn(/#{c}::FOO is deprecated/) {Class.new(c)::FOO}
- bug12382 = '[ruby-core:75505] [Bug #12382]'
- assert_warn(/deprecated/, bug12382) {c.class_eval "FOO"}
- Warning[:deprecated] = false
- assert_warn('') {c::FOO}
- end
- NIL = nil
- FALSE = false
- deprecate_constant(:NIL, :FALSE)
- def test_deprecate_nil_constant
- w = EnvUtil.verbose_warning {2.times {FALSE}}
- assert_equal(1, w.scan("::FALSE").size, w)
- w = EnvUtil.verbose_warning {2.times {NIL}}
- assert_equal(1, w.scan("::NIL").size, w)
- end
- def test_constants_with_private_constant
- assert_not_include(::TestModule.constants, :PrivateClass)
- assert_not_include(::TestModule.constants(true), :PrivateClass)
- assert_not_include(::TestModule.constants(false), :PrivateClass)
- end
- def test_toplevel_private_constant
- src = <<-INPUT
- class Object
- private_constant :Object
- end
- p Object
- begin
- p ::Object
- rescue
- p :ok
- end
- INPUT
- assert_in_out_err([], src, %w(Object :ok), [])
- end
- def test_private_constants_clear_inlinecache
- bug5702 = '[ruby-dev:44929]'
- src = <<-INPUT
- class A
- C = :Const
- def self.get_C
- A::C
- end
- # fill cache
- A.get_C
- private_constant :C, :D rescue nil
- begin
- A.get_C
- rescue NameError
- puts "A.get_C"
- end
- end
- INPUT
- assert_in_out_err([], src, %w(A.get_C), [], bug5702)
- end
- def test_constant_lookup_in_method_defined_by_class_eval
- src = <<-INPUT
- class A
- B = 42
- end
- A.class_eval do
- def self.f
- B
- end
- def f
- B
- end
- end
- begin
- A.f
- rescue NameError
- puts "A.f"
- end
- begin
- A.new.f
- rescue NameError
- puts "A.new.f"
- end
- INPUT
- assert_in_out_err([], src, %w(A.f A.new.f), [])
- end
- def test_constant_lookup_in_toplevel_class_eval
- src = <<-INPUT
- module X
- A = 123
- end
- begin
- X.class_eval { A }
- rescue NameError => e
- puts e
- end
- INPUT
- assert_in_out_err([], src, ["uninitialized constant A"], [])
- end
- def test_constant_lookup_in_module_in_class_eval
- src = <<-INPUT
- class A
- B = 42
- end
- A.class_eval do
- module C
- begin
- B
- rescue NameError
- puts "NameError"
- end
- end
- end
- INPUT
- assert_in_out_err([], src, ["NameError"], [])
- end
- module M0
- def m1; [:M0] end
- end
- module M1
- def m1; [:M1, *super] end
- end
- module M2
- def m1; [:M2, *super] end
- end
- M3 = Module.new do
- def m1; [:M3, *super] end
- end
- module M4
- def m1; [:M4, *super] end
- end
- class C
- def m1; end
- end
- class C0 < C
- include M0
- prepend M1
- def m1; [:C0, *super] end
- end
- class C1 < C0
- prepend M2, M3
- include M4
- def m1; [:C1, *super] end
- end
- def test_prepend
- obj = C0.new
- expected = [:M1,:C0,:M0]
- assert_equal(expected, obj.m1)
- obj = C1.new
- expected = [:M2,:M3,:C1,:M4,:M1,:C0,:M0]
- assert_equal(expected, obj.m1)
- end
- def test_public_prepend
- assert_nothing_raised('#8846') do
- Class.new.prepend(Module.new)
- end
- end
- def test_prepend_CMP
- bug11878 = '[ruby-core:72493] [Bug #11878]'
- assert_equal(-1, C1 <=> M2)
- assert_equal(+1, M2 <=> C1, bug11878)
- end
- def test_prepend_inheritance
- bug6654 = '[ruby-core:45914]'
- a = labeled_module("a")
- b = labeled_module("b") {include a}
- c = labeled_class("c") {prepend b}
- assert_operator(c, :<, b, bug6654)
- assert_operator(c, :<, a, bug6654)
- bug8357 = '[ruby-core:54736] [Bug #8357]'
- b = labeled_module("b") {prepend a}
- c = labeled_class("c") {include b}
- assert_operator(c, :<, b, bug8357)
- assert_operator(c, :<, a, bug8357)
- bug8357 = '[ruby-core:54742] [Bug #8357]'
- assert_kind_of(b, c.new, bug8357)
- end
- def test_prepend_instance_methods
- bug6655 = '[ruby-core:45915]'
- assert_equal(Object.instance_methods, Class.new {prepend Module.new}.instance_methods, bug6655)
- end
- def test_prepend_singleton_methods
- o = Object.new
- o.singleton_class.class_eval {prepend Module.new}
- assert_equal([], o.singleton_methods)
- end
- def test_prepend_remove_method
- c = Class.new do
- prepend Module.new {def foo; end}
- end
- assert_raise(NameError) do
- c.class_eval do
- remove_method(:foo)
- end
- end
- c.class_eval do
- def foo; end
- end
- removed = nil
- c.singleton_class.class_eval do
- define_method(:method_removed) {|id| removed = id}
- end
- assert_nothing_raised(NoMethodError, NameError, '[Bug #7843]') do
- c.class_eval do
- remove_method(:foo)
- end
- end
- assert_equal(:foo, removed)
- end
- def test_prepend_class_ancestors
- bug6658 = '[ruby-core:45919]'
- m = labeled_module("m")
- c = labeled_class("c") {prepend m}
- asser…
Large files files are truncated, but you can click here to view the full file