third-party/mruby/test/t/class.rb

   1 ##
   2 # Class ISO Test
   3
   4 assert('Class', '15.2.3') do
   5   assert_equal(Class, Class.class)
   6 end
   7
   8 assert('Class#initialize', '15.2.3.3.1') do
   9   c = Class.new do
  10     def test
  11       :test
  12     end
  13   end.new
  14
  15   assert_equal(c.test, :test)
  16 end
  17
  18 assert('Class#initialize_copy', '15.2.3.3.2') do
  19   class TestClass
  20     attr_accessor :n
  21     def initialize(n)
  22       @n = n
  23     end
  24     def initialize_copy(obj)
  25       @n = n
  26     end
  27   end
  28
  29   c1 = TestClass.new('Foo')
  30   c2 = c1.dup
  31   c3 = TestClass.new('Bar')
  32
  33   assert_equal(c1.n, c2.n)
  34   assert_not_equal(c1.n, c3.n)
  35 end
  36
  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
  40   end
  41
  42   class TestClass
  43     def initialize args, &block
  44       @result = if not args.nil? and block.nil?
  45         # only arguments
  46         :only_args
  47       elsif not args.nil? and not block.nil?
  48         # args and block is given
  49         :args_and_block
  50       else
  51         # this should never happen
  52         :broken
  53       end
  54     end
  55
  56     def result; @result; end
  57   end
  58
  59   assert_equal(:only_args, TestClass.new(:arg).result)
  60   # with block doesn't work yet
  61 end
  62
  63 assert('Class#superclass', '15.2.3.3.4') do
  64   class SubClass < String; end
  65   assert_equal(String, SubClass.superclass)
  66 end
  67
  68 # Not ISO specified
  69
  70 assert('Class 1') do
  71   class C1; end
  72   assert_equal(Class, C1.class)
  73 end
  74
  75 assert('Class 2') do
  76   class C2; end
  77   assert_equal(C2, C2.new.class)
  78 end
  79
  80 assert('Class 3') do
  81   class C3; end
  82   assert_equal(Class, C3.new.class.class)
  83 end
  84
  85 assert('Class 4') do
  86   class C4_A; end
  87   class C4 < C4_A; end
  88   assert_equal(Class, C4.class)
  89 end
  90
  91 assert('Class 5') do
  92   class C5_A; end
  93   class C5 < C5_A; end
  94   assert_equal(C5, C5.new.class)
  95 end
  96
  97 assert('Class 6') do
  98   class C6_A; end
  99   class C6 < C6_A; end
 100   assert_equal(Class, C6.new.class.class)
 101 end
 102
 103 assert('Class 7') do
 104   class C7_A; end
 105   class C7_B; end
 106
 107   class C7 < C7_A; end
 108
 109   assert_raise(TypeError) do
 110     # Different superclass.
 111     class C7 < C7_B; end
 112   end
 113 end
 114
 115 assert('Class 8') do
 116   class C8_A; end
 117
 118   class C8; end  # superclass is Object
 119
 120   assert_raise(TypeError) do
 121     # Different superclass.
 122     class C8 < C8_A; end
 123   end
 124 end
 125
 126 assert('Class 9') do
 127   Class9Const = "a"
 128
 129   assert_raise(TypeError) do
 130     class Class9Const; end
 131   end
 132 end
 133
 134 assert('Class Module 1') do
 135   module M; end
 136   assert_equal(Module, M.class)
 137 end
 138
 139 assert('Class Module 2') do
 140   module M; end
 141   class C; include M; end
 142   assert_equal(C, C.new.class)
 143 end
 144
 145 # nested class
 146 assert('Class Nested 1') do
 147   class A; end
 148   class A::B; end
 149   assert_equal(A::B, A::B)
 150 end
 151
 152 assert('Class Nested 2') do
 153   class A; end
 154   class A::B; end
 155   assert_equal(A::B, A::B.new.class)
 156 end
 157
 158 assert('Class Nested 3') do
 159   class A; end
 160   class A::B; end
 161   assert_equal(Class, A::B.new.class.class)
 162 end
 163
 164 assert('Class Nested 4') do
 165   class A; end
 166   class A::B; end
 167   class A::B::C; end
 168   assert_equal(A::B::C, A::B::C)
 169 end
 170
 171 assert('Class Nested 5') do
 172   class A; end
 173   class A::B; end
 174   class A::B::C; end
 175   assert_equal(Class, A::B::C.class)
 176 end
 177
 178 assert('Class Nested 6') do
 179   class A; end
 180   class A::B; end
 181   class A::B::C; end
 182   assert_equal(A::B::C, A::B::C.new.class)
 183 end
 184
 185 assert('Class Nested 7') do
 186   class A; end
 187   class A::B; end
 188   class A::B2 < A::B; end
 189   assert_equal(A::B2, A::B2)
 190 end
 191
 192 assert('Class Nested 8') do
 193   class A; end
 194   class A::B; end
 195   class A::B2 < A::B; end
 196   assert_equal(Class, A::B2.class)
 197 end
 198
 199 assert('Class Colon 1') do
 200   class A; end
 201   A::C = 1
 202   assert_equal(1, A::C)
 203 end
 204
 205 assert('Class Colon 2') do
 206   class A; class ::C; end end
 207   assert_equal(C, C)
 208 end
 209
 210 assert('Class Colon 3') do
 211   class A; class ::C; end end
 212   assert_equal(Class, C.class)
 213 end
 214
 215 assert('Class Dup 1') do
 216   class C; end
 217   assert_equal(Class, C.dup.class)
 218 end
 219
 220 assert('Class Dup 2') do
 221   module M; end
 222   assert_equal(Module, M.dup.class)
 223 end
 224
 225 assert('Class.new') do
 226   assert_equal(Class, Class.new.class)
 227   a = []
 228   klass = Class.new do |c|
 229     a << c
 230   end
 231   assert_equal([klass], a)
 232 end
 233
 234 assert('class to return the last value') do
 235   m = class C; :m end
 236   assert_equal(m, :m)
 237 end
 238
 239 assert('class to return nil if body is empty') do
 240   assert_nil(class C end)
 241   assert_nil(class << self; end)
 242 end
 243
 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
 248   end
 249
 250   class SecondClass; end
 251   assert_raise(TypeError, 'should raise TypeError') do
 252     class SecondClass < false; end
 253   end
 254
 255   class ThirdClass; end
 256   assert_raise(TypeError, 'should raise TypeError') do
 257     class ThirdClass < ThirdClass; end
 258   end
 259 end
 260
 261 assert('Class#inherited') do
 262   class Foo
 263     @@subclass_name = nil
 264     def self.inherited(subclass)
 265       @@subclass_name = subclass
 266     end
 267     def self.subclass_name
 268       @@subclass_name
 269     end
 270   end
 271
 272   assert_equal(nil, Foo.subclass_name)
 273
 274   class Bar < Foo
 275   end
 276
 277   assert_equal(Bar, Foo.subclass_name)
 278
 279   class Baz < Bar
 280   end
 281
 282   assert_equal(Baz, Foo.subclass_name)
 283 end
 284
 285 assert('singleton tests') do
 286   module FooMod
 287     def run_foo_mod
 288       100
 289     end
 290   end
 291
 292   bar = String.new
 293
 294   baz = class << bar
 295     extend FooMod
 296     def self.run_baz
 297       200
 298     end
 299   end
 300
 301   assert_equal :run_baz, baz
 302
 303   assert_raise(NoMethodError, 'should raise NoMethodError') do
 304     bar.run_foo_mod
 305   end
 306   assert_raise(NoMethodError, 'should raise NoMethodError') do
 307     bar.run_baz
 308   end
 309
 310   baz = class << bar
 311     extend FooMod
 312     def self.run_baz
 313       300
 314     end
 315     self
 316   end
 317
 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
 322
 323   assert_raise(NoMethodError, 'should raise NoMethodError') do
 324     bar.run_foo_mod
 325   end
 326   assert_raise(NoMethodError, 'should raise NoMethodError') do
 327     bar.run_baz
 328   end
 329
 330   fv = false
 331   class << fv
 332     def self.run_false
 333       5
 334     end
 335   end
 336
 337   nv = nil
 338   class << nv
 339     def self.run_nil
 340       6
 341     end
 342   end
 343
 344   tv = true
 345   class << tv
 346     def self.run_nil
 347       7
 348     end
 349   end
 350
 351   assert_raise(TypeError, 'should raise TypeError') do
 352     num = 1.0
 353     class << num
 354       def self.run_nil
 355         7
 356       end
 357     end
 358   end if Object.const_defined?(:Float)
 359 end
 360
 361 assert('clone Class') do
 362   class Foo
 363     def func
 364       true
 365     end
 366   end
 367
 368   assert_true(Foo.clone.new.func)
 369 end
 370
 371 assert('class variable and class << self style class method') do
 372   class ClassVariableTest
 373     @@class_variable = "value"
 374     class << self
 375       def class_variable
 376         @@class_variable
 377       end
 378     end
 379   end
 380
 381   assert_equal("value", ClassVariableTest.class_variable)
 382 end
 383
 384 assert('class variable definition in singleton_class') do
 385   class ClassVariableDefinitionInSingletonTest
 386     class << self
 387       @@class_variable = "value"
 388     end
 389     def class_variable
 390       @@class_variable
 391     end
 392   end
 393
 394   assert_equal("value", ClassVariableDefinitionInSingletonTest.new.class_variable)
 395 end
 396
 397 assert('class variable in module and class << self style class method') do
 398   module ClassVariableInModuleTest
 399     @@class_variable = "value"
 400     class << self
 401       def class_variable
 402         @@class_variable
 403       end
 404     end
 405   end
 406
 407   assert_equal("value", ClassVariableInModuleTest.class_variable)
 408 end
 409
 410 assert('child class/module defined in singleton class get parent constant') do
 411   actual = module GetParentConstantTest
 412             EXPECT = "value"
 413             class << self
 414               class CHILD
 415                 class << self
 416                     EXPECT
 417                 end
 418               end
 419             end
 420           end
 421   assert_equal("value", actual)
 422 end
 423
 424 assert('overriding class variable with a module (#3235)') do
 425   module ModuleWithCVar
 426     @@class_variable = 1
 427   end
 428   class CVarOverrideTest
 429     @@class_variable = 2
 430     include ModuleWithCVar
 431
 432     assert_equal(1, @@class_variable)
 433   end
 434 end
 435
 436 assert('class with non-class/module outer raises TypeError') do
 437   assert_raise(TypeError) { class 0::C1; end }
 438   assert_raise(TypeError) { class []::C2; end }
 439 end