/test/testCornerCases.rb
Ruby | 257 lines | 153 code | 67 blank | 37 comment | 0 complexity | b0b5cc1b62909a39e31642a7fc60038a MD5 | raw file
Possible License(s): GPL-3.0, JSON
- require 'test/unit'
- class TestClassCornerCases < Test::Unit::TestCase
- def setup
- super
- @cls = Class
- @mod = Module
- end
-
- class AllocatedClassSubclass < Class.allocate;end
- class NewClassSubclass < Class.new;end
- def test_class_allocate
- assert_nothing_raised{@cls.allocate}
- # uninitialized class
- assert_raise(TypeError){@cls.allocate.superclass}
- # can't instantiate uninitialized class
- assert_raise(TypeError){@cls.allocate.new}
- # allocator undefined for AllocatedClassSubclass
- assert_raise(TypeError){AllocatedClassSubclass.new}
- assert_raise(TypeError){AllocatedClassSubclass.allocate}
-
- assert_nothing_raised{@cls.allocate.dup}
- assert_nothing_raised{@cls.allocate.clone}
- end
- def test_class_initialize
- @allocated = Class.allocate
- assert_nothing_raised{@allocated.send(:initialize, String)}
- assert_equal(@allocated.superclass, String)
- # already initialized class
- assert_raise(TypeError){@allocated.send(:initialize, String)}
- end
- def test_class_initialize_copy
- @allocated = Class.allocate
- assert_nothing_raised{@allocated.send(:initialize_copy, String)}
- assert_equal(@allocated.superclass, Object)
- @allocated = Class.allocate
- # initialize_copy should take same class object
- assert_raise(TypeError){@allocated.send(:initialize_copy,"")}
- end
-
- def test_class_new
- assert_nothing_raised{@cls.new.allocate}
- assert_nothing_raised{@cls.new(@cls)}
- assert_nothing_raised{@cls.new(@mod).new}
- # wrong instance allocation
- assert_raise(TypeError){@cls.new(@cls).new}
- assert_raise(TypeError){@cls.new(@cls).allocate}
- # superclass must be a class
- assert_raise(TypeError){@cls.new("")}
- # wrong intance allocation
- assert_raise(TypeError){@cls.dup.new("")}
- assert_raise(TypeError){@cls.clone.new("")}
-
- # allocator undefined for #<Class:0x...>
- assert_raise(TypeError){@cls.new(@cls.allocate.dup).new}
- assert_raise(TypeError){@cls.new(@cls.allocate.clone).new}
-
- assert_nothing_raised{NewClassSubclass.new}
- assert_nothing_raised{NewClassSubclass.allocate}
- end
-
- def test_singleton_class
- o = Object.new
- s = class<<Object;self;end
- # can't create instance of virtual class
- assert_raise(TypeError){s.allocate}
- assert_raise(TypeError){s.new}
- assert_raise(TypeError){eval "class Class < class<<Object;self;end;end"}
- # can't copy singleton class
- assert_raise(TypeError){s.dup}
- assert_raise(TypeError){s.clone}
- # already initialized class (TypeError)
- assert_raise(TypeError){s.send(:initialize)}
- assert_raise(TypeError){s.send(:initialize_copy,"")}
- # can't make subclass of virtual class
- assert_raise(TypeError){@cls.new(s)}
- end
- end
- class TestConstantCornerCases < Test::Unit::TestCase
- def test_parent_not_changed_on_constant_assignemnt
- assert_equal("M::A", eval( <<-EOF
- $a=Class.new
- module M
- A=$a
- end
- module N
- B=$a
- end
- return N::B.to_s
- EOF
- ))
- end
- def teardown
- $a = nil
- end
- end
- class TestInheritanceAndReopeningCornerCases < Test::Unit::TestCase
- module AModule;end
- class AClass;end
- def test_class_module_reopen
- assert_nothing_raised{eval "module AModule;end"}
- assert_nothing_raised{eval "class AClass;end"}
- # AModule is not a class
- assert_raise(TypeError){eval "class AModule;end"}
- # AClass is not a module
- assert_raise(TypeError){eval "module AClass;end"}
- # superclass mismatch for class AClass
- assert_raise(TypeError){eval "class AClass<String;end"}
- # superclass must be a Class (Fixnum given)
- assert_raise(TypeError){eval "class AClass<1;end"}
- end
-
- def test_weird_things_allowed_by_parser
- # can't make subclass of virtual class
- assert_raise(TypeError){eval "class AClass<class<<self;self;end;end"}
- assert_nothing_raised{"class C < Class.new(Class.allocate.dup);end"}
- # allocator undefined for C
- assert_nothing_raised{"class C < Class.new(Class.allocate.dup);end;C.new"}
- end
- end
- class TestMarshalCornerCases < Test::Unit::TestCase
- class AClass;end
- OldClass = AClass
- class AModule;end
- AnInstance = AClass.new
- ASingleton = class<<AnInstance;self;end
- def setup
- end
- def marshal_dump(*obj)
- Marshal.dump obj
- end
- def marshal_load(*str)
- Marshal.load *str
- end
- def marshal_dump_and_load(*obj)
- Marshal.load(Marshal.dump(obj))
- end
- def test_marshal_singleton
- # can't dump anonymous class #<Class:0x28404fc>
- assert_raise(TypeError){marshal_dump Class.new}
- assert_raise(TypeError){marshal_dump Class.allocate}
-
- # can't dump anonymous module #<Module:01xcd2e33>
- assert_raise(TypeError){marshal_dump Module.allocate}
-
- assert_nothing_raised{marshal_dump Object.new}
- assert_nothing_raised{marshal_dump Object.allocate}
- assert_nothing_raised{marshal_dump AClass}
- # a class that that has a singleton without ivars can be dumped
- assert_nothing_raised{marshal_dump AnInstance}
- # singleton class can't be dumped
- assert_raise(TypeError){marshal_dump ASingleton}
- ASingleton.instance_eval{@foo=:blah}
- # singleton can't be dumped
- assert_raise(TypeError){marshal_dump AnInstance}
- end
- class AnotherClass;end
- module AnotherModule;end
- module AnotherModule2;end
- $set_class = lambda{|c|AnotherClass=c}
- $set_module = lambda{|c|AnotherModule=c}
- $set_module2 = lambda{|c|AnotherModule2=c}
- def test_incomplete_type_system_unmarshal_sanity
- stream = marshal_dump(AnotherClass.new)
- #p AnotherClass
- $set_class[nil]
- # TestMarshalCornerCases::AnotherClass does not refer class/module
- assert_raise(TypeError){marshal_load(stream)}
- $set_class[Kernel]
- # TestMarshalCornerCases::AnotherClass does not refer class
- assert_raise(ArgumentError){marshal_load(stream)}
- #$set_class[String]
- # # dump format error
- #assert_raise(ArgumentError){marshal_load(stream)}
- stream = marshal_dump(AnotherModule)
- $set_module[nil]
- # TestMarshalCornerCases::AnotherClass does not refer class/module
- assert_raise(TypeError){marshal_load(stream)}
- stream = marshal_dump(AnotherModule2)
- $set_module2[String]
- # TestMarshalCornerCases::AnotherModule2 does not refer module
- assert_raise(ArgumentError){marshal_load(stream)}
- end
-
- def teardown
- $set_class = $set_module = $set_module2 = nil
- end
- end
- class TestBuiltinClassesOverwrittenCornerCases < Test::Unit::TestCase
- def test_core_constants_removed_sanity
- # we will have to fire a separate runtime here for this
- # the runtime should either use Constants cached in runtime or use Ruby.getClassFromPath
- # and raise TypeErrors if appropriate
-
- # Object.constants.each{|c|Object.const_set(c, nil) unless ["Object", "Module", "Class"].include? c}
- end
- end
- class TestUninitializedInstanceSanity < Test::Unit::TestCase
-
- def test_uninitialized_core_classe
- # core class instance sanity after calling plain #allocate without initialization
- end
- end