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

   1 ##
   2 # Module ISO Test
   3
   4 def labeled_module(name, &block)
   5   Module.new do
   6     (class <<self; self end).class_eval do
   7       define_method(:to_s) { name }
   8       alias_method :inspect, :to_s
   9     end
  10     class_eval(&block) if block
  11   end
  12 end
  13
  14 def labeled_class(name, supklass = Object, &block)
  15   Class.new(supklass) do
  16     (class <<self; self end).class_eval do
  17       define_method(:to_s) { name }
  18       alias_method :inspect, :to_s
  19     end
  20     class_eval(&block) if block
  21   end
  22 end
  23
  24 def assert_uninitialized_const(&block)
  25   assert_raise_with_message_pattern(NameError, "uninitialized constant *", &block)
  26 end
  27
  28 def assert_wrong_const_name(&block)
  29   assert_raise_with_message_pattern(NameError, "wrong constant name *", &block)
  30 end
  31
  32 assert('Module', '15.2.2') do
  33   assert_equal Class, Module.class
  34 end
  35
  36 assert('Module#alias_method', '15.2.2.4.8') do
  37   cls = Class.new do
  38     def foo
  39       "FOO"
  40     end
  41   end
  42
  43   assert_same(cls, cls.alias_method(:bar, :foo))
  44   assert_equal("FOO", cls.new.bar)
  45 end
  46
  47 # TODO not implemented ATM assert('Module.constants', '15.2.2.3.1') do
  48
  49 assert('Module#ancestors', '15.2.2.4.9') do
  50   class Test4ModuleAncestors
  51   end
  52   r = String.ancestors
  53
  54   assert_equal Array, r.class
  55   assert_true r.include?(String)
  56   assert_true r.include?(Object)
  57 end
  58
  59 assert('Module#append_features', '15.2.2.4.10') do
  60   module Test4AppendFeatures
  61     def self.append_features(mod)
  62       Test4AppendFeatures2.const_set(:Const4AppendFeatures2, mod)
  63     end
  64   end
  65   module Test4AppendFeatures2
  66     include Test4AppendFeatures
  67   end
  68
  69   assert_equal Test4AppendFeatures2, Test4AppendFeatures2.const_get(:Const4AppendFeatures2)
  70   assert_raise(FrozenError) { Module.new.append_features Class.new.freeze }
  71 end
  72
  73 assert('Module#attr NameError') do
  74   %w[
  75     foo?
  76     @foo
  77     @@foo
  78     $foo
  79   ].each do |name|
  80     module NameTest; end
  81
  82     assert_raise(NameError) do
  83       NameTest.module_eval { attr_reader name.to_sym }
  84     end
  85
  86     assert_raise(NameError) do
  87       NameTest.module_eval { attr_writer name.to_sym }
  88     end
  89
  90     assert_raise(NameError) do
  91       NameTest.module_eval { attr name.to_sym }
  92     end
  93
  94     assert_raise(NameError) do
  95       NameTest.module_eval { attr_accessor name.to_sym }
  96     end
  97   end
  98
  99 end
 100
 101 assert('Module#attr', '15.2.2.4.11') do
 102   class AttrTest
 103     class << self
 104       attr :cattr
 105       def cattr_val=(val)
 106         @cattr = val
 107       end
 108     end
 109     attr :iattr
 110     def iattr_val=(val)
 111       @iattr = val
 112     end
 113   end
 114
 115   test = AttrTest.new
 116   assert_true AttrTest.respond_to?(:cattr)
 117   assert_true test.respond_to?(:iattr)
 118
 119   assert_false AttrTest.respond_to?(:cattr=)
 120   assert_false test.respond_to?(:iattr=)
 121
 122   test.iattr_val = 'test'
 123   assert_equal 'test', test.iattr
 124
 125   AttrTest.cattr_val = 'test'
 126   assert_equal 'test', AttrTest.cattr
 127 end
 128
 129 assert('Module#attr_accessor', '15.2.2.4.12') do
 130   class AttrTestAccessor
 131     class << self
 132       attr_accessor :cattr
 133     end
 134     attr_accessor :iattr, 'iattr2'
 135   end
 136
 137   attr_instance = AttrTestAccessor.new
 138   assert_true AttrTestAccessor.respond_to?(:cattr=)
 139   assert_true attr_instance.respond_to?(:iattr=)
 140   assert_true attr_instance.respond_to?(:iattr2=)
 141   assert_true AttrTestAccessor.respond_to?(:cattr)
 142   assert_true attr_instance.respond_to?(:iattr)
 143   assert_true attr_instance.respond_to?(:iattr2)
 144
 145   attr_instance.iattr = 'test'
 146   assert_equal 'test', attr_instance.iattr
 147
 148   AttrTestAccessor.cattr = 'test'
 149   assert_equal 'test', AttrTestAccessor.cattr
 150 end
 151
 152 assert('Module#attr_reader', '15.2.2.4.13') do
 153   class AttrTestReader
 154     class << self
 155       attr_reader :cattr
 156       def cattr_val=(val)
 157         @cattr = val
 158       end
 159     end
 160     attr_reader :iattr, 'iattr2'
 161     def iattr_val=(val)
 162       @iattr = val
 163     end
 164   end
 165
 166   attr_instance = AttrTestReader.new
 167   assert_true AttrTestReader.respond_to?(:cattr)
 168   assert_true attr_instance.respond_to?(:iattr)
 169   assert_true attr_instance.respond_to?(:iattr2)
 170
 171   assert_false AttrTestReader.respond_to?(:cattr=)
 172   assert_false attr_instance.respond_to?(:iattr=)
 173   assert_false attr_instance.respond_to?(:iattr2=)
 174
 175   attr_instance.iattr_val = 'test'
 176   assert_equal 'test', attr_instance.iattr
 177
 178   AttrTestReader.cattr_val = 'test'
 179   assert_equal 'test', AttrTestReader.cattr
 180 end
 181
 182 assert('Module#attr_writer', '15.2.2.4.14') do
 183   class AttrTestWriter
 184     class << self
 185       attr_writer :cattr
 186       def cattr_val
 187         @cattr
 188       end
 189     end
 190     attr_writer :iattr, 'iattr2'
 191     def iattr_val
 192       @iattr
 193     end
 194   end
 195
 196   attr_instance = AttrTestWriter.new
 197   assert_true AttrTestWriter.respond_to?(:cattr=)
 198   assert_true attr_instance.respond_to?(:iattr=)
 199   assert_true attr_instance.respond_to?(:iattr2=)
 200
 201   assert_false AttrTestWriter.respond_to?(:cattr)
 202   assert_false attr_instance.respond_to?(:iattr)
 203   assert_false attr_instance.respond_to?(:iattr2)
 204
 205   attr_instance.iattr = 'test'
 206   assert_equal 'test', attr_instance.iattr_val
 207
 208   AttrTestWriter.cattr = 'test'
 209   assert_equal 'test', AttrTestWriter.cattr_val
 210 end
 211
 212 assert('Module#class_eval', '15.2.2.4.15') do
 213   class Test4ClassEval
 214     @a = 11
 215     @b = 12
 216   end
 217   Test4ClassEval.class_eval do
 218     def method1
 219     end
 220   end
 221   assert_equal 11, Test4ClassEval.class_eval{ @a }
 222   assert_equal 12, Test4ClassEval.class_eval{ @b }
 223   assert_equal true, Test4ClassEval.new.respond_to?(:method1)
 224 end
 225
 226 assert('Module#const_defined?', '15.2.2.4.20') do
 227   module Test4ConstDefined
 228     Const4Test4ConstDefined = true
 229   end
 230
 231   assert_true Test4ConstDefined.const_defined?(:Const4Test4ConstDefined)
 232   assert_false Test4ConstDefined.const_defined?(:NotExisting)
 233   assert_wrong_const_name{ Test4ConstDefined.const_defined?(:wrong_name) }
 234 end
 235
 236 assert('Module#const_get', '15.2.2.4.21') do
 237   module Test4ConstGet
 238     Const4Test4ConstGet = 42
 239   end
 240
 241   assert_equal 42, Test4ConstGet.const_get(:Const4Test4ConstGet)
 242   assert_equal 42, Test4ConstGet.const_get("Const4Test4ConstGet")
 243   assert_equal 42, Object.const_get("Test4ConstGet::Const4Test4ConstGet")
 244
 245   assert_raise(TypeError){ Test4ConstGet.const_get(123) }
 246   assert_uninitialized_const{ Test4ConstGet.const_get(:I_DO_NOT_EXIST) }
 247   assert_uninitialized_const{ Test4ConstGet.const_get("I_DO_NOT_EXIST::ME_NEITHER") }
 248   assert_wrong_const_name{ Test4ConstGet.const_get(:wrong_name) }
 249 end
 250
 251 assert('Module#const_set', '15.2.2.4.23') do
 252   module Test4ConstSet
 253     Const4Test4ConstSet = 42
 254   end
 255
 256   assert_equal 23, Test4ConstSet.const_set(:Const4Test4ConstSet, 23)
 257   assert_equal 23, Test4ConstSet.const_get(:Const4Test4ConstSet)
 258   ["", "wrongNAME", "Wrong-Name"].each do |n|
 259     assert_wrong_const_name { Test4ConstSet.const_set(n, 1) }
 260   end
 261 end
 262
 263 assert('Module#remove_const', '15.2.2.4.40') do
 264   module Test4RemoveConst
 265     ExistingConst = 23
 266   end
 267
 268   assert_equal 23, Test4RemoveConst.remove_const(:ExistingConst)
 269   assert_false Test4RemoveConst.const_defined?(:ExistingConst)
 270   assert_raise_with_message_pattern(NameError, "constant * not defined") do
 271     Test4RemoveConst.remove_const(:NonExistingConst)
 272   end
 273   %i[x X!].each do |n|
 274     assert_wrong_const_name { Test4RemoveConst.remove_const(n) }
 275   end
 276   assert_raise(FrozenError) { Test4RemoveConst.freeze.remove_const(:A) }
 277 end
 278
 279 assert('Module#const_missing', '15.2.2.4.22') do
 280   module Test4ConstMissing
 281     def self.const_missing(sym)
 282       42 # the answer to everything
 283     end
 284   end
 285
 286   assert_equal 42, Test4ConstMissing.const_get(:ConstDoesntExist)
 287 end
 288
 289 assert('Module#extend_object', '15.2.2.4.25') do
 290   cls = Class.new
 291   mod = Module.new { def foo; end }
 292   a = cls.new
 293   b = cls.new
 294   mod.extend_object(b)
 295   assert_false a.respond_to?(:foo)
 296   assert_true b.respond_to?(:foo)
 297   assert_raise(FrozenError) { mod.extend_object(cls.new.freeze) }
 298   assert_raise(FrozenError, TypeError) { mod.extend_object(1) }
 299 end
 300
 301 assert('Module#include', '15.2.2.4.27') do
 302   module Test4Include
 303     Const4Include = 42
 304   end
 305   module Test4Include2
 306     @include_result = include Test4Include
 307     class << self
 308       attr_reader :include_result
 309     end
 310   end
 311
 312   assert_equal 42, Test4Include2.const_get(:Const4Include)
 313   assert_equal Test4Include2, Test4Include2.include_result
 314   assert_raise(FrozenError) { Module.new.freeze.include Test4Include }
 315 end
 316
 317 assert('Module#include?', '15.2.2.4.28') do
 318   module Test4IncludeP
 319   end
 320   class Test4IncludeP2
 321     include Test4IncludeP
 322   end
 323   class Test4IncludeP3 < Test4IncludeP2
 324   end
 325
 326   assert_true Test4IncludeP2.include?(Test4IncludeP)
 327   assert_true Test4IncludeP3.include?(Test4IncludeP)
 328   assert_false Test4IncludeP.include?(Test4IncludeP)
 329 end
 330
 331 assert('Module#included', '15.2.2.4.29') do
 332   module Test4Included
 333     Const4Included = 42
 334     def self.included mod
 335       Test4Included.const_set(:Const4Included2, mod)
 336     end
 337   end
 338   module Test4Included2
 339     include Test4Included
 340   end
 341
 342   assert_equal 42, Test4Included2.const_get(:Const4Included)
 343   assert_equal Test4Included2, Test4Included2.const_get(:Const4Included2)
 344 end
 345
 346 assert('Module#initialize', '15.2.2.4.31') do
 347   assert_kind_of Module, Module.new
 348   mod = Module.new { def hello; "hello"; end }
 349   cls = Class.new{include mod}
 350   assert_true cls.new.respond_to?(:hello)
 351   a = nil
 352   mod = Module.new { |m| a = m }
 353   assert_equal mod, a
 354 end
 355
 356 assert('Module#method_defined?', '15.2.2.4.34') do
 357   module Test4MethodDefined
 358     module A
 359       def method1()  end
 360     end
 361
 362     class B
 363       def method2()  end
 364     end
 365
 366     class C < B
 367       include A
 368       def method3()  end
 369     end
 370   end
 371
 372   assert_true Test4MethodDefined::A.method_defined? :method1
 373   assert_true Test4MethodDefined::C.method_defined? :method1
 374   assert_true Test4MethodDefined::C.method_defined? "method2"
 375   assert_true Test4MethodDefined::C.method_defined? "method3"
 376   assert_false Test4MethodDefined::C.method_defined? "method4"
 377 end
 378
 379 assert('Module#module_eval', '15.2.2.4.35') do
 380   module Test4ModuleEval
 381     @a = 11
 382     @b = 12
 383   end
 384
 385   assert_equal 11, Test4ModuleEval.module_eval{ @a }
 386   assert_equal 12, Test4ModuleEval.module_eval{ @b }
 387 end
 388
 389 assert('Module#undef_method', '15.2.2.4.42') do
 390   module Test4UndefMethod
 391     class Parent
 392       def hello
 393       end
 394      end
 395
 396      class Child < Parent
 397       def hello
 398       end
 399      end
 400
 401      class GrandChild < Child
 402      end
 403   end
 404   Test4UndefMethod::Child.class_eval{ undef_method :hello }
 405
 406   assert_true Test4UndefMethod::Parent.new.respond_to?(:hello)
 407   assert_false Test4UndefMethod::Child.new.respond_to?(:hello)
 408   assert_false Test4UndefMethod::GrandChild.new.respond_to?(:hello)
 409 end
 410
 411 # Not ISO specified
 412
 413 assert('Module#dup') do
 414   module TestModuleDup
 415     @@cvar = :cvar
 416     class << self
 417       attr_accessor :cattr
 418       def cmeth; :cmeth end
 419     end
 420     def cvar; @@cvar end
 421     def imeth; :imeth end
 422     self.cattr = :cattr
 423   end
 424
 425   m = TestModuleDup.dup
 426   o = Object.include(m).new
 427   assert_equal(:cattr, m.cattr)
 428   assert_equal(:cmeth, m.cmeth)
 429   assert_equal(:cvar, o.cvar)
 430   assert_equal(:imeth, o.imeth)
 431   assert_match("#<Module:0x*>", m.to_s)
 432   assert_not_predicate(m, :frozen?)
 433   assert_not_predicate(TestModuleDup.freeze.dup, :frozen?)
 434 end
 435
 436 assert('Module#define_method') do
 437   c = Class.new {
 438     define_method(:m1) { :ok }
 439     define_method(:m2, Proc.new { :ok })
 440   }
 441   assert_equal c.new.m1, :ok
 442   assert_equal c.new.m2, :ok
 443   assert_raise(TypeError) do
 444     Class.new { define_method(:n1, nil) }
 445   end
 446 end
 447
 448 assert 'Module#prepend_features' do
 449   mod = Module.new { def m; :mod end }
 450   cls = Class.new { def m; :cls end }
 451   assert_equal :cls, cls.new.m
 452   mod.prepend_features(cls)
 453   assert_equal :mod, cls.new.m
 454   assert_raise(FrozenError) { Module.new.prepend_features(Class.new.freeze) }
 455 end
 456
 457 # @!group prepend
 458   assert('Module#prepend') do
 459     module M0
 460       def m1; [:M0] end
 461     end
 462     module M1
 463       def m1; [:M1, super, :M1] end
 464     end
 465     module M2
 466       def m1; [:M2, super, :M2] end
 467     end
 468     M3 = Module.new do
 469       def m1; [:M3, super, :M3] end
 470     end
 471     module M4
 472       def m1; [:M4, super, :M4] end
 473     end
 474
 475     class P0
 476       include M0
 477       prepend M1
 478       def m1; [:C0, super, :C0] end
 479     end
 480     class P1 < P0
 481       prepend M2, M3
 482       include M4
 483       def m1; [:C1, super, :C1] end
 484     end
 485
 486     obj = P1.new
 487     expected = [:M2,[:M3,[:C1,[:M4,[:M1,[:C0,[:M0],:C0],:M1],:M4],:C1],:M3],:M2]
 488     assert_equal(expected, obj.m1)
 489   end
 490
 491   assert('Module#prepend result') do
 492     module TestPrepended; end
 493     module TestPrependResult
 494       @prepend_result = prepend TestPrepended
 495       class << self
 496         attr_reader :prepend_result
 497       end
 498     end
 499
 500     assert_equal TestPrependResult, TestPrependResult.prepend_result
 501   end
 502
 503   # mruby shouldn't be affected by this since there is
 504   # no visibility control (yet)
 505   assert('Module#prepend public') do
 506     assert_nothing_raised('ruby/ruby #8846') do
 507       Class.new.prepend(Module.new)
 508     end
 509   end
 510
 511   assert('Module#prepend inheritance') do
 512     bug6654 = '[ruby-core:45914]'
 513     a = labeled_module('a')
 514     b = labeled_module('b') { include a }
 515     c = labeled_module('c') { prepend b }
 516
 517     #assert bug6654 do
 518       # the Module#< operator should be used here instead, but we don't have it
 519       assert_include(c.ancestors, a)
 520       assert_include(c.ancestors, b)
 521     #end
 522
 523     bug8357 = '[ruby-core:54736] [Bug #8357]'
 524     b = labeled_module('b') { prepend a }
 525     c = labeled_class('c') { include b }
 526
 527     #assert bug8357 do
 528       # the Module#< operator should be used here instead, but we don't have it
 529       assert_include(c.ancestors, a)
 530       assert_include(c.ancestors, b)
 531     #end
 532
 533     bug8357 = '[ruby-core:54742] [Bug #8357]'
 534     assert_kind_of(b, c.new, bug8357)
 535   end
 536
 537   assert 'Module#prepend + Class#ancestors' do
 538     bug6658 = '[ruby-core:45919]'
 539     m = labeled_module("m")
 540     c = labeled_class("c") {prepend m}
 541     assert_equal([m, c], c.ancestors[0, 2], bug6658)
 542
 543     bug6662 = '[ruby-dev:45868]'
 544     c2 = labeled_class("c2", c)
 545     anc = c2.ancestors
 546     assert_equal([c2, m, c, Object], anc[0..anc.index(Object)], bug6662)
 547   end
 548
 549   assert 'Module#prepend + Module#ancestors' do
 550     bug6659 = '[ruby-dev:45861]'
 551     m0 = labeled_module("m0") { def x; [:m0, *super] end }
 552     m1 = labeled_module("m1") { def x; [:m1, *super] end; prepend m0 }
 553     m2 = labeled_module("m2") { def x; [:m2, *super] end; prepend m1 }
 554     c0 = labeled_class("c0") { def x; [:c0] end }
 555     c1 = labeled_class("c1") { def x; [:c1] end; prepend m2 }
 556     c2 = labeled_class("c2", c0) { def x; [:c2, *super] end; include m2 }
 557     #
 558     assert_equal([m0, m1], m1.ancestors, bug6659)
 559     #
 560     bug6662 = '[ruby-dev:45868]'
 561     assert_equal([m0, m1, m2], m2.ancestors, bug6662)
 562     assert_equal([m0, m1, m2, c1], c1.ancestors[0, 4], bug6662)
 563     assert_equal([:m0, :m1, :m2, :c1], c1.new.x)
 564     assert_equal([c2, m0, m1, m2, c0], c2.ancestors[0, 5], bug6662)
 565     assert_equal([:c2, :m0, :m1, :m2, :c0], c2.new.x)
 566     #
 567     m3 = labeled_module("m3") { include m1; prepend m1 }
 568     assert_equal([m3, m0, m1], m3.ancestors)
 569     m3 = labeled_module("m3") { prepend m1; include m1 }
 570     assert_equal([m0, m1, m3], m3.ancestors)
 571     m3 = labeled_module("m3") { prepend m1; prepend m1 }
 572     assert_equal([m0, m1, m3], m3.ancestors)
 573     m3 = labeled_module("m3") { include m1; include m1 }
 574     assert_equal([m3, m0, m1], m3.ancestors)
 575   end
 576
 577   assert 'cyclic Module#prepend' do
 578     bug7841 = '[ruby-core:52205] [Bug #7841]'
 579     m1 = Module.new
 580     m2 = Module.new
 581     m1.instance_eval { prepend(m2) }
 582     assert_raise(ArgumentError, bug7841) do
 583       m2.instance_eval { prepend(m1) }
 584     end
 585   end
 586
 587   # these assertions will not run without a #assert_separately method
 588   #assert 'test_prepend_optmethod' do
 589   #  bug7983 = '[ruby-dev:47124] [Bug #7983]'
 590   #  assert_separately [], %{
 591   #    module M
 592   #      def /(other)
 593   #        to_f / other
 594   #      end
 595   #    end
 596   #    Fixnum.send(:prepend, M)
 597   #    assert_equal(0.5, 1 / 2, "#{bug7983}")
 598   #  }
 599   #  assert_equal(0, 1 / 2)
 600   #end
 601
 602   # mruby has no visibility control
 603   # assert 'Module#prepend visibility' do
 604   #   bug8005 = '[ruby-core:53106] [Bug #8005]'
 605   #   c = Class.new do
 606   #     prepend Module.new {}
 607   #     def foo() end
 608   #     protected :foo
 609   #   end
 610   #   a = c.new
 611   #   assert_true a.respond_to?(:foo), bug8005
 612   #   assert_nothing_raised(bug8005) {a.send :foo}
 613   # end
 614
 615   # mruby has no visibility control
 616   # assert 'Module#prepend inherited visibility' do
 617   #   bug8238 = '[ruby-core:54105] [Bug #8238]'
 618   #   module Test4PrependVisibilityInherited
 619   #     class A
 620   #       def foo() A; end
 621   #       private :foo
 622   #     end
 623   #     class B < A
 624   #       public :foo
 625   #       prepend Module.new
 626   #     end
 627   #   end
 628   #   assert_equal(Test4PrependVisibilityInherited::A, Test4PrependVisibilityInherited::B.new.foo, "#{bug8238}")
 629   # end
 630
 631   # assert 'Module#prepend super in alias' do
 632   #   skip "super does not currently work in aliased methods"
 633   #   bug7842 = '[Bug #7842]'
 634
 635   #   p = labeled_module("P") do
 636   #     def m; "P"+super; end
 637   #   end
 638
 639   #   a = labeled_class("A") do
 640   #     def m; "A"; end
 641   #   end
 642
 643   #   b = labeled_class("B", a) do
 644   #     def m; "B"+super; end
 645   #     alias m2 m
 646   #     prepend p
 647   #     alias m3 m
 648   #   end
 649
 650   #   assert_nothing_raised do
 651   #     assert_equal("BA", b.new.m2, bug7842)
 652   #   end
 653
 654   #   assert_nothing_raised do
 655   #     assert_equal("PBA", b.new.m3, bug7842)
 656   #   end
 657   # end
 658
 659   assert 'Module#prepend each class' do
 660     m = labeled_module("M")
 661     c1 = labeled_class("C1") {prepend m}
 662     c2 = labeled_class("C2", c1) {prepend m}
 663     assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should be able to prepend each class")
 664   end
 665
 666   assert 'Module#prepend no duplication' do
 667     m = labeled_module("M")
 668     c = labeled_class("C") {prepend m; prepend m}
 669     assert_equal([m, c], c.ancestors[0, 2], "should never duplicate")
 670   end
 671
 672   assert 'Module#prepend in superclass' do
 673     m = labeled_module("M")
 674     c1 = labeled_class("C1")
 675     c2 = labeled_class("C2", c1) {prepend m}
 676     c1.class_eval {prepend m}
 677     assert_equal([m, c2, m, c1], c2.ancestors[0, 4], "should accesisble prepended module in superclass")
 678   end
 679
 680   # requires #assert_separately
 681   #assert 'Module#prepend call super' do
 682   #  assert_separately([], <<-'end;') #do
 683   #    bug10847 = '[ruby-core:68093] [Bug #10847]'
 684   #    module M; end
 685   #    Float.prepend M
 686   #    assert_nothing_raised(SystemStackError, bug10847) do
 687   #      0.3.numerator
 688   #    end
 689   #  end;
 690   #end
 691
 692   assert 'Module#prepend to frozen class' do
 693     assert_raise(FrozenError) { Class.new.freeze.prepend Module.new }
 694   end
 695 # @!endgroup prepend
 696
 697 assert('Module#to_s') do
 698   module Outer
 699     class Inner; end
 700     const_set :SetInner, Class.new
 701   end
 702
 703   assert_equal 'Outer', Outer.to_s
 704   assert_equal 'Outer::Inner', Outer::Inner.to_s
 705   assert_equal 'Outer::SetInner', Outer::SetInner.to_s
 706
 707   outer = Module.new do
 708     const_set :SetInner, Class.new
 709   end
 710   Object.const_set :SetOuter, outer
 711
 712   assert_equal 'SetOuter', SetOuter.to_s
 713   assert_equal 'SetOuter::SetInner', SetOuter::SetInner.to_s
 714
 715   assert_match "#<Module:0x*>", Module.new.to_s
 716   assert_match "#<Class:0x*>", Class.new.to_s
 717
 718   assert_equal "FrozenClassToS", (FrozenClassToS = Class.new.freeze).to_s
 719   assert_equal "Outer::A", (Outer::A = Module.new.freeze).to_s
 720   assert_match "#<Module:0x*>::A", (Module.new::A = Class.new.freeze).to_s
 721 end
 722
 723 assert('Module#inspect') do
 724   module Test4to_sModules
 725   end
 726
 727   assert_equal 'Test4to_sModules', Test4to_sModules.inspect
 728 end
 729
 730 assert('Issue 1467') do
 731   module M1
 732     def initialize()
 733       super()
 734     end
 735   end
 736
 737   class C1
 738     include M1
 739      def initialize()
 740        super()
 741      end
 742   end
 743
 744   class C2
 745     include M1
 746   end
 747
 748   assert_kind_of(M1, C1.new)
 749   assert_kind_of(M1, C2.new)
 750 end
 751
 752 assert('clone Module') do
 753   module M1
 754     def foo
 755       true
 756     end
 757   end
 758
 759   class B
 760     include M1.clone
 761   end
 762
 763   assert_true(B.new.foo)
 764 end
 765
 766 assert('Module#module_function') do
 767   module M
 768     def modfunc; end
 769     module_function :modfunc
 770   end
 771
 772   assert_true M.respond_to?(:modfunc)
 773 end
 774
 775 assert('module with non-class/module outer raises TypeError') do
 776   assert_raise(TypeError) { module 0::M1 end }
 777   assert_raise(TypeError) { module []::M2 end }
 778 end
 779
 780 assert('module to return the last value') do
 781   m = module M; :m end
 782   assert_equal(m, :m)
 783 end
 784
 785 assert('module to return nil if body is empty') do
 786   assert_nil(module M end)
 787 end
 788
 789 assert('get constant of parent module in singleton class; issue #3568') do
 790   actual = module GetConstantInSingletonTest
 791     EXPECTED = "value"
 792     class << self
 793       EXPECTED
 794     end
 795   end
 796
 797   assert_equal("value", actual)
 798 end