1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
ruby--ruby/test/ruby/test_class.rb

631 lines
15 KiB
Ruby
Raw Normal View History

# frozen_string_literal: false
require 'test/unit'
class TestClass < Test::Unit::TestCase
# ------------------
# Various test classes
# ------------------
class ClassOne
attr :num_args
@@subs = []
def initialize(*args)
@num_args = args.size
@args = args
end
def [](n)
@args[n]
end
def ClassOne.inherited(klass)
@@subs.push klass
end
def subs
@@subs
end
end
class ClassTwo < ClassOne
end
class ClassThree < ClassOne
end
class ClassFour < ClassThree
end
# ------------------
# Start of tests
# ------------------
def test_s_inherited
assert_equal([ClassTwo, ClassThree, ClassFour], ClassOne.new.subs)
end
def test_s_new
c = Class.new
assert_same(Class, c.class)
assert_same(Object, c.superclass)
c = Class.new(Integer)
assert_same(Class, c.class)
assert_same(Integer, c.superclass)
end
def test_00_new_basic
a = ClassOne.new
assert_equal(ClassOne, a.class)
assert_equal(0, a.num_args)
a = ClassOne.new(1, 2, 3)
assert_equal(3, a.num_args)
assert_equal(1, a[0])
end
def test_01_new_inherited
a = ClassTwo.new
assert_equal(ClassTwo, a.class)
assert_equal(0, a.num_args)
a = ClassTwo.new(1, 2, 3)
assert_equal(3, a.num_args)
assert_equal(1, a[0])
end
def test_superclass
assert_equal(ClassOne, ClassTwo.superclass)
assert_equal(Object, ClassTwo.superclass.superclass)
assert_equal(BasicObject, ClassTwo.superclass.superclass.superclass)
end
def test_class_cmp
assert_raise(TypeError) { Class.new <= 1 }
assert_raise(TypeError) { Class.new >= 1 }
assert_nil(Class.new <=> 1)
end
def test_class_initialize
assert_raise(TypeError) do
Class.new.instance_eval { initialize }
end
end
def test_instantiate_singleton_class
c = class << Object.new; self; end
assert_raise(TypeError) { c.new }
end
def test_superclass_of_basicobject
assert_equal(nil, BasicObject.superclass)
end
def test_module_function
c = Class.new
assert_raise(TypeError) do
Module.instance_method(:module_function).bind(c).call(:foo)
end
end
def test_extend_object
c = Class.new
assert_raise(TypeError) do
Module.instance_method(:extend_object).bind(c).call(Object.new)
end
end
def test_append_features
c = Class.new
assert_raise(TypeError) do
Module.instance_method(:append_features).bind(c).call(Module.new)
end
end
def test_prepend_features
c = Class.new
assert_raise(TypeError) do
Module.instance_method(:prepend_features).bind(c).call(Module.new)
end
end
def test_module_specific_methods
assert_empty(Class.private_instance_methods(true) &
[:module_function, :extend_object, :append_features, :prepend_features])
end
def test_method_redefinition
feature2155 = '[ruby-dev:39400]'
line = __LINE__+4
stderr = EnvUtil.verbose_warning do
Class.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
Class.new do
def foo; end
alias bar foo
def foo; end
end
end
assert_warning '' do
Class.new do
def foo; end
alias bar foo
alias bar foo
end
end
line = __LINE__+4
stderr = EnvUtil.verbose_warning do
Class.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
Class.new do
define_method(:foo) do end
alias bar foo
alias bar foo
end
end
assert_warning '' do
Class.new do
def foo; end
undef foo
end
end
end
def test_check_inheritable
assert_raise(TypeError) { Class.new(Object.new) }
o = Object.new
c = class << o; self; end
assert_raise(TypeError) { Class.new(c) }
assert_raise(TypeError) { Class.new(Class) }
assert_raise(TypeError) { eval("class Foo < Class; end") }
m = "M\u{1f5ff}"
o = Class.new {break eval("class #{m}; self; end.new")}
assert_raise_with_message(TypeError, /#{m}/) {Class.new(o)}
end
def test_initialize_copy
c = Class.new
assert_raise(TypeError) { c.instance_eval { initialize_copy(1) } }
o = Object.new
c = class << o; self; end
assert_raise(TypeError) { c.dup }
assert_raise(TypeError) { BasicObject.dup }
end
def test_singleton_class
assert_raise(TypeError) { 1.extend(Module.new) }
assert_raise(TypeError) { 1.0.extend(Module.new) }
assert_raise(TypeError) { (2.0**1000).extend(Module.new) }
assert_raise(TypeError) { :foo.extend(Module.new) }
assert_in_out_err([], <<-INPUT, %w(:foo :foo true true), [])
module Foo; def foo; :foo; end; end
false.extend(Foo)
true.extend(Foo)
p false.foo
p true.foo
p FalseClass.include?(Foo)
p TrueClass.include?(Foo)
INPUT
end
def test_uninitialized
assert_raise(TypeError) { Class.allocate.new }
assert_raise(TypeError) { Class.allocate.superclass }
bug6863 = '[ruby-core:47148]'
assert_raise(TypeError, bug6863) { Class.new(Class.allocate) }
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("TestClass::C\u{df}", c.name, '[ruby-core:24600]')
end
def test_invalid_next_from_class_definition
assert_syntax_error("class C; next; end", /Invalid next/)
end
def test_invalid_break_from_class_definition
assert_syntax_error("class C; break; end", /Invalid break/)
end
def test_invalid_redo_from_class_definition
assert_syntax_error("class C; redo; end", /Invalid redo/)
end
def test_invalid_retry_from_class_definition
assert_syntax_error("class C; retry; end", /Invalid retry/)
end
def test_invalid_return_from_class_definition
assert_syntax_error("class C; return; end", /Invalid return/)
end
def test_invalid_yield_from_class_definition
assert_raise(LocalJumpError) {
EnvUtil.suppress_warning {eval("class C; yield; end")}
}
end
def test_clone
original = Class.new {
def foo
return super()
end
}
mod = Module.new {
def foo
return "mod#foo"
end
}
copy = original.clone
copy.send(:include, mod)
assert_equal("mod#foo", copy.new.foo)
end
def test_nested_class_removal
assert_normal_exit('File.__send__(:remove_const, :Stat); at_exit{File.stat(".")}; GC.start')
end
class PrivateClass
end
private_constant :PrivateClass
def test_redefine_private_class
assert_raise(NameError) do
eval("class ::TestClass::PrivateClass; end")
end
eval <<-END
class ::TestClass
class PrivateClass
def foo; 42; end
end
end
END
assert_equal(42, PrivateClass.new.foo)
end
StrClone = String.clone
Class.new(StrClone)
def test_cloned_class
bug5274 = StrClone.new("[ruby-dev:44460]")
assert_equal(bug5274, Marshal.load(Marshal.dump(bug5274)))
end
def test_cannot_reinitialize_class_with_initialize_copy # [ruby-core:50869]
assert_in_out_err([], "#{<<~"begin;"}\n#{<<~'end;'}", ["Object"], [])
begin;
class Class
def initialize_copy(*); super; end
end
class A; end
class B; end
A.send(:initialize_copy, Class.new(B)) rescue nil
p A.superclass
end;
end
module M
C = 1
def self.m
C
end
end
def test_constant_access_from_method_in_cloned_module # [ruby-core:47834]
m = M.dup
assert_equal 1, m::C
assert_equal 1, m.m
end
def test_invalid_superclass
assert_raise(TypeError) do
eval <<-'end;'
class C < nil
end
end;
end
assert_raise(TypeError) do
eval <<-'end;'
class C < false
end
end;
end
assert_raise(TypeError) do
eval <<-'end;'
class C < true
end
end;
end
assert_raise(TypeError) do
eval <<-'end;'
class C < 0
end
end;
end
assert_raise(TypeError) do
eval <<-'end;'
class C < ""
end
end;
end
m = Module.new
n = "M\u{1f5ff}"
c = m.module_eval "class #{n}; new; end"
assert_raise_with_message(TypeError, /#{n}/) {
eval <<-"end;"
class C < c
end
end;
}
assert_raise_with_message(TypeError, /#{n}/) {
Class.new(c)
}
assert_raise_with_message(TypeError, /#{n}/) {
m.module_eval "class #{n} < Class.new; end"
}
end
define_method :test_invalid_reset_superclass do
class A; end
class SuperclassCannotBeReset < A
end
assert_equal A, SuperclassCannotBeReset.superclass
assert_raise_with_message(TypeError, /superclass mismatch/) {
class SuperclassCannotBeReset < String
end
}
assert_raise_with_message(TypeError, /superclass mismatch/, "[ruby-core:75446]") {
class SuperclassCannotBeReset < Object
end
}
assert_equal A, SuperclassCannotBeReset.superclass
end
def test_cloned_singleton_method_added
bug5283 = '[ruby-dev:44477]'
added = []
c = Class.new
c.singleton_class.class_eval do
define_method(:singleton_method_added) {|mid| added << [self, mid]}
def foo; :foo; end
end
added.clear
d = c.clone
assert_empty(added.grep(->(k) {c == k[0]}), bug5283)
assert_equal(:foo, d.foo)
end
def test_singleton_class_p
feature7609 = '[ruby-core:51087] [Feature #7609]'
assert_predicate(self.singleton_class, :singleton_class?, feature7609)
assert_not_predicate(self.class, :singleton_class?, feature7609)
end
def test_freeze_to_s
assert_nothing_raised("[ruby-core:41858] [Bug #5828]") {
Class.new.freeze.clone.to_s
}
end
def test_singleton_class_of_frozen_object
obj = Object.new
c = obj.singleton_class
obj.freeze
assert_raise_with_message(FrozenError, /frozen object/) {
c.class_eval {def f; end}
}
end
def test_singleton_class_message
c = Class.new.freeze
assert_raise_with_message(FrozenError, /frozen Class/) {
def c.f; end
}
end
def test_singleton_class_should_has_own_namespace
# CONST in singleton class
objs = []
$i = 0
2.times{
objs << obj = Object.new
class << obj
CONST = ($i += 1)
def foo
CONST
end
end
}
assert_equal(1, objs[0].foo, '[Bug #10943]')
assert_equal(2, objs[1].foo, '[Bug #10943]')
# CONST in block in singleton class
objs = []
$i = 0
2.times{
objs << obj = Object.new
class << obj
1.times{
CONST = ($i += 1)
}
def foo
[nil].map{
CONST
}
end
end
}
assert_equal([1], objs[0].foo, '[Bug #10943]')
assert_equal([2], objs[1].foo, '[Bug #10943]')
# class def in singleton class
objs = []
$xs = []
$i = 0
2.times{
objs << obj = Object.new
class << obj
CONST = ($i += 1)
class X
$xs << self
CONST = ($i += 1)
def foo
CONST
end
end
def x
X
end
end
}
assert_not_equal($xs[0], $xs[1], '[Bug #10943]')
assert_not_equal(objs[0].x, objs[1].x, '[Bug #10943]')
assert_equal(2, $xs[0]::CONST, '[Bug #10943]')
assert_equal(2, $xs[0].new.foo, '[Bug #10943]')
assert_equal(4, $xs[1]::CONST, '[Bug #10943]')
assert_equal(4, $xs[1].new.foo, '[Bug #10943]')
# class def in block in singleton class
objs = []
$xs = []
$i = 0
2.times{
objs << obj = Object.new
class << obj
1.times{
CONST = ($i += 1)
}
1.times{
class X
$xs << self
CONST = ($i += 1)
def foo
CONST
end
end
def x
X
end
}
end
}
assert_not_equal($xs[0], $xs[1], '[Bug #10943]')
assert_not_equal(objs[0].x, objs[1].x, '[Bug #10943]')
assert_equal(2, $xs[0]::CONST, '[Bug #10943]')
assert_equal(2, $xs[0].new.foo, '[Bug #10943]')
assert_equal(4, $xs[1]::CONST, '[Bug #10943]')
assert_equal(4, $xs[1].new.foo, '[Bug #10943]')
# method def in singleton class
ms = []
ps = $test_singleton_class_shared_cref_ps = []
2.times{
ms << Module.new do
class << self
$test_singleton_class_shared_cref_ps << Proc.new{
def xyzzy
self
end
}
end
end
}
ps.each{|p| p.call} # define xyzzy methods for each singleton classes
ms.each{|m|
assert_equal(m, m.xyzzy, "Bug #10871")
}
end
def test_namescope_error_message
m = Module.new
o = m.module_eval "class A\u{3042}; self; end.new"
assert_raise_with_message(TypeError, /A\u{3042}/) {
o::Foo
}
end
def test_redefinition_mismatch
m = Module.new
m.module_eval "A = 1"
assert_raise_with_message(TypeError, /is not a class/) {
m.module_eval "class A; end"
}
n = "M\u{1f5ff}"
m.module_eval "#{n} = 42"
assert_raise_with_message(TypeError, "#{n} is not a class") {
m.module_eval "class #{n}; end"
}
assert_separately([], "#{<<~"begin;"}\n#{<<~"end;"}")
begin;
Date = (class C\u{1f5ff}; self; end).new
assert_raise_with_message(TypeError, /C\u{1f5ff}/) {
require 'date'
}
end;
end
def test_should_not_expose_singleton_class_without_metaclass
assert_normal_exit "#{<<~"begin;"}\n#{<<~'end;'}", '[Bug #11740]'
begin;
klass = Class.new(Array)
# The metaclass of +klass+ should handle #bla since it should inherit methods from meta:meta:Array
def (Array.singleton_class).bla; :bla; end
hidden = ObjectSpace.each_object(Class).find { |c| klass.is_a? c and c.inspect.include? klass.inspect }
raise unless hidden.nil?
end;
assert_normal_exit "#{<<~"begin;"}\n#{<<~'end;'}", '[Bug #11740]'
begin;
klass = Class.new(Array)
klass.singleton_class
# The metaclass of +klass+ should handle #bla since it should inherit methods from meta:meta:Array
def (Array.singleton_class).bla; :bla; end
hidden = ObjectSpace.each_object(Class).find { |c| klass.is_a? c and c.inspect.include? klass.inspect }
raise if hidden.nil?
end;
end
end