4 assert('Class', '15.2.3') do
5 assert_equal(Class, Class.class)
8 assert('Class#initialize', '15.2.3.3.1') do
15 assert_equal(c.test, :test)
18 assert('Class#initialize_copy', '15.2.3.3.2') do
24 def initialize_copy(obj)
29 c1 = TestClass.new('Foo')
31 c3 = TestClass.new('Bar')
33 assert_equal(c1.n, c2.n)
34 assert_not_equal(c1.n, c3.n)
37 assert('Class#new', '15.2.3.3.3') do
38 assert_raise(TypeError, 'Singleton should raise TypeError') do
39 (class <<"a"; self; end).new
43 def initialize args, &block
44 @result = if not args.nil? and block.nil?
47 elsif not args.nil? and not block.nil?
48 # args and block is given
51 # this should never happen
56 def result; @result; end
59 assert_equal(:only_args, TestClass.new(:arg).result)
60 # with block doesn't work yet
63 assert('Class#superclass', '15.2.3.3.4') do
64 class SubClass < String; end
65 assert_equal(String, SubClass.superclass)
72 assert_equal(Class, C1.class)
77 assert_equal(C2, C2.new.class)
82 assert_equal(Class, C3.new.class.class)
88 assert_equal(Class, C4.class)
94 assert_equal(C5, C5.new.class)
100 assert_equal(Class, C6.new.class.class)
109 assert_raise(TypeError) do
110 # Different superclass.
118 class C8; end # superclass is Object
120 assert_raise(TypeError) do
121 # Different superclass.
129 assert_raise(TypeError) do
130 class Class9Const; end
134 assert('Class Module 1') do
136 assert_equal(Module, M.class)
139 assert('Class Module 2') do
141 class C; include M; end
142 assert_equal(C, C.new.class)
146 assert('Class Nested 1') do
149 assert_equal(A::B, A::B)
152 assert('Class Nested 2') do
155 assert_equal(A::B, A::B.new.class)
158 assert('Class Nested 3') do
161 assert_equal(Class, A::B.new.class.class)
164 assert('Class Nested 4') do
168 assert_equal(A::B::C, A::B::C)
171 assert('Class Nested 5') do
175 assert_equal(Class, A::B::C.class)
178 assert('Class Nested 6') do
182 assert_equal(A::B::C, A::B::C.new.class)
185 assert('Class Nested 7') do
188 class A::B2 < A::B; end
189 assert_equal(A::B2, A::B2)
192 assert('Class Nested 8') do
195 class A::B2 < A::B; end
196 assert_equal(Class, A::B2.class)
199 assert('Class Colon 1') do
202 assert_equal(1, A::C)
205 assert('Class Colon 2') do
206 class A; class ::C; end end
210 assert('Class Colon 3') do
211 class A; class ::C; end end
212 assert_equal(Class, C.class)
215 assert('Class Dup 1') do
217 assert_equal(Class, C.dup.class)
220 assert('Class Dup 2') do
222 assert_equal(Module, M.dup.class)
225 assert('Class.new') do
226 assert_equal(Class, Class.new.class)
228 klass = Class.new do |c|
231 assert_equal([klass], a)
234 assert('class to return the last value') do
239 assert('class to return nil if body is empty') do
240 assert_nil(class C end)
241 assert_nil(class << self; end)
244 assert('raise when superclass is not a class') do
245 module FirstModule; end
246 assert_raise(TypeError, 'should raise TypeError') do
247 class FirstClass < FirstModule; end
250 class SecondClass; end
251 assert_raise(TypeError, 'should raise TypeError') do
252 class SecondClass < false; end
255 class ThirdClass; end
256 assert_raise(TypeError, 'should raise TypeError') do
257 class ThirdClass < ThirdClass; end
261 assert('Class#inherited') do
263 @@subclass_name = nil
264 def self.inherited(subclass)
265 @@subclass_name = subclass
267 def self.subclass_name
272 assert_equal(nil, Foo.subclass_name)
277 assert_equal(Bar, Foo.subclass_name)
282 assert_equal(Baz, Foo.subclass_name)
285 assert('singleton tests') do
301 assert_equal :run_baz, baz
303 assert_raise(NoMethodError, 'should raise NoMethodError') do
306 assert_raise(NoMethodError, 'should raise NoMethodError') do
318 assert_true baz.respond_to? :run_baz
319 assert_true baz.respond_to? :run_foo_mod
320 assert_equal 100, baz.run_foo_mod
321 assert_equal 300, baz.run_baz
323 assert_raise(NoMethodError, 'should raise NoMethodError') do
326 assert_raise(NoMethodError, 'should raise NoMethodError') do
351 assert_raise(TypeError, 'should raise TypeError') do
358 end if Object.const_defined?(:Float)
361 sc = class << o; self end
363 assert_predicate(sc, :frozen?)
365 assert_predicate(class << Object.new.freeze; self end, :frozen?)
368 assert('clone Class') do
375 assert_true(Foo.clone.new.func)
378 assert('class variable and class << self style class method') do
379 class ClassVariableTest
380 @@class_variable = "value"
388 assert_equal("value", ClassVariableTest.class_variable)
391 assert('class variable definition in singleton_class') do
392 class ClassVariableDefinitionInSingletonTest
394 @@class_variable = "value"
401 assert_equal("value", ClassVariableDefinitionInSingletonTest.new.class_variable)
404 assert('class variable in module and class << self style class method') do
405 module ClassVariableInModuleTest
406 @@class_variable = "value"
414 assert_equal("value", ClassVariableInModuleTest.class_variable)
417 assert('child class/module defined in singleton class get parent constant') do
418 actual = module GetParentConstantTest
428 assert_equal("value", actual)
431 assert('overriding class variable with a module (#3235)') do
432 module ModuleWithCVar
435 class CVarOverrideTest
437 include ModuleWithCVar
439 assert_equal(1, @@class_variable)
443 assert('class variable for frozen class/module') do
444 module CVarForFrozenModule
446 assert_raise(FrozenError) { @@cv = 1 }
449 class CVarForFrozenClassA
453 class CVarForFrozenClassB < CVarForFrozenClassA
458 b = CVarForFrozenClassB.new
459 assert_raise(FrozenError) { b.a = 1 }
462 assert('class with non-class/module outer raises TypeError') do
463 assert_raise(TypeError) { class 0::C1; end }
464 assert_raise(TypeError) { class []::C2; end }