Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

501 lines (439 sloc) 11.256 kb
module MarshalTestLib
# include this module to a Test::Unit::TestCase and definde encode(o) and
# decode(s) methods. e.g.
#
# def encode(o)
# SOAPMarshal.dump(o)
# end
#
# def decode(s)
# SOAPMarshal.load(s)
# end
NegativeZero = (-1.0 / (1.0 / 0.0))
module Mod1; end
module Mod2; end
def marshaltest(o1)
str = encode(o1)
print str, "\n" if $DEBUG
o2 = decode(str)
o2
end
def marshal_equal(o1, msg = nil)
msg = msg ? msg + "(#{ caller[0] })" : caller[0]
o2 = marshaltest(o1)
assert_equal(o1.class, o2.class, msg)
iv1 = o1.instance_variables.sort
iv2 = o2.instance_variables.sort
assert_equal(iv1, iv2)
val1 = iv1.map {|var| o1.instance_eval {eval var}}
val2 = iv1.map {|var| o2.instance_eval {eval var}}
assert_equal(val1, val2, msg)
if block_given?
assert_equal(yield(o1), yield(o2), msg)
else
assert_equal(o1, o2, msg)
end
end
class MyObject; def initialize(v) @v = v end; attr_reader :v; end
def test_object
o1 = Object.new
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_object_subclass
marshal_equal(MyObject.new(2)) {|o| o.v}
end
def test_object_extend
o1 = Object.new
o1.extend(Mod1)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
o1.extend(Mod2)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
end
def test_object_subclass_extend
o1 = MyObject.new(2)
o1.extend(Mod1)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
o1.extend(Mod2)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
end
class MyArray < Array
def initialize(v, *args)
super(args)
@v = v
end
end
def test_array
marshal_equal(5)
marshal_equal([1,2,3])
end
def test_array_subclass
marshal_equal(MyArray.new(0, 1, 2, 3))
end
def test_array_ivar
o1 = Array.new
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
class MyException < Exception; def initialize(v, *args) super(*args); @v = v; end; attr_reader :v; end
def test_exception
marshal_equal(Exception.new('foo')) {|o| o.message}
marshal_equal(assert_raise(NoMethodError) {no_such_method()}) {|o| o.message}
end
def test_exception_subclass
marshal_equal(MyException.new(20, "bar")) {|o| [o.message, o.v]}
end
def test_false
marshal_equal(false)
end
class MyHash < Hash; def initialize(v, *args) super(*args); @v = v; end end
def test_hash
marshal_equal({1=>2, 3=>4})
end
def test_hash_default
h = Hash.new(:default)
h[5] = 6
marshal_equal(h)
end
def test_hash_subclass
h = MyHash.new(7, 8)
h[4] = 5
marshal_equal(h)
end
def test_hash_default_proc
h = Hash.new {}
assert_raises(TypeError) { marshaltest(h) }
end
def test_hash_ivar
o1 = Hash.new
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_hash_extend
o1 = Hash.new
o1.extend(Mod1)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
o1.extend(Mod2)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
end
def test_hash_subclass_extend
o1 = MyHash.new(2)
o1.extend(Mod1)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
o1.extend(Mod2)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
end
def test_bignum
marshal_equal(-0x4000_0000_0000_0001)
marshal_equal(-0x4000_0001)
marshal_equal(0x4000_0000)
marshal_equal(0x4000_0000_0000_0000)
end
def test_fixnum
marshal_equal(-0x4000_0000)
marshal_equal(-0x3fff_ffff)
marshal_equal(-1)
marshal_equal(0)
marshal_equal(1)
marshal_equal(0x3fff_ffff)
end
def test_fixnum_ivar
o1 = 1
o1.instance_eval { @iv = 2 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
ensure
1.instance_eval { remove_instance_variable("@iv") }
end
def test_fixnum_ivar_self
o1 = 1
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
ensure
1.instance_eval { remove_instance_variable("@iv") }
end
def test_fixnum_64bit
obj = [1220278665, 1220278662, 1220278661, 1220278661, 1220278656]
marshal_equal(obj)
end
def test_float
marshal_equal(-1.0)
marshal_equal(0.0)
marshal_equal(1.0)
end
def test_float_inf_nan
marshal_equal(1.0/0.0)
marshal_equal(-1.0/0.0)
marshal_equal(0.0/0.0) {|o| o.nan?}
marshal_equal(NegativeZero) {|o| 1.0/o}
end
def test_float_ivar
o1 = 1.23
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_float_ivar_self
o1 = 5.5
o1.instance_eval { @iv = o1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_float_extend
o1 = 0.0/0.0
o1.extend(Mod1)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
o1.extend(Mod2)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
end
class MyRange < Range; def initialize(v, *args) super(*args); @v = v; end end
def test_range
marshal_equal(1..2)
marshal_equal(1...3)
end
def test_range_subclass
marshal_equal(MyRange.new(4,5,8, false))
end
class MyRegexp < Regexp; def initialize(v, *args) super(*args); @v = v; end end
def test_regexp
marshal_equal(/a/)
marshal_equal(/A/i)
marshal_equal(/A/mx)
end
def test_regexp_subclass
marshal_equal(MyRegexp.new(10, "a"))
end
class MyString < String; def initialize(v, *args) super(*args); @v = v; end end
def test_string
marshal_equal("abc")
end
def test_string_ivar
o1 = ""
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_string_subclass
marshal_equal(MyString.new(10, "a"))
end
def test_string_subclass_cycle
str = MyString.new(10, "b")
str.instance_eval { @v = str }
marshal_equal(str) { |o|
assert_equal(o.__id__, o.instance_eval { @v }.__id__)
o.instance_eval { @v }
}
end
def test_string_subclass_extend
o = "abc"
o.extend(Mod1)
str = MyString.new(o, "c")
marshal_equal(str) { |o|
assert(o.instance_eval { @v }).kind_of?(Mod1)
}
end
MyStruct = Struct.new("MyStruct", :a, :b)
if RUBY_VERSION < "1.8.0"
# Struct#== is not defined in ruby/1.6
class MyStruct
def ==(rhs)
return true if __id__ == rhs.__id__
return false unless rhs.is_a?(::Struct)
return false if self.class != rhs.class
members.each do |member|
return false if self.__send__(member) != rhs.__send__(member)
end
return true
end
end
end
class MySubStruct < MyStruct; def initialize(v, *args) super(*args); @v = v; end end
def test_struct
marshal_equal(MyStruct.new(1,2))
end
def test_struct_subclass
if RUBY_VERSION < "1.8.0"
# Substruct instance cannot be dumped in ruby/1.6
# ::Marshal.dump(MySubStruct.new(10, 1, 2)) #=> uninitialized struct
return false
end
marshal_equal(MySubStruct.new(10,1,2))
end
def test_struct_ivar
o1 = MyStruct.new
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_struct_subclass_extend
o1 = MyStruct.new
o1.extend(Mod1)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
o1.extend(Mod2)
marshal_equal(o1) { |o|
(class << self; self; end).ancestors
}
end
def test_symbol
marshal_equal(:a)
marshal_equal(:a?)
marshal_equal(:a!)
marshal_equal(:a=)
marshal_equal(:|)
marshal_equal(:^)
marshal_equal(:&)
marshal_equal(:<=>)
marshal_equal(:==)
marshal_equal(:===)
marshal_equal(:=~)
marshal_equal(:>)
marshal_equal(:>=)
marshal_equal(:<)
marshal_equal(:<=)
marshal_equal(:<<)
marshal_equal(:>>)
marshal_equal(:+)
marshal_equal(:-)
marshal_equal(:*)
marshal_equal(:/)
marshal_equal(:%)
marshal_equal(:**)
marshal_equal(:~)
marshal_equal(:+@)
marshal_equal(:-@)
marshal_equal(:[])
marshal_equal(:[]=)
marshal_equal(:`) #`
marshal_equal("a b".intern)
end
class MyTime < Time; def initialize(v, *args) super(*args); @v = v; end end
def test_time
# once there was a bug caused by usec overflow. try a little harder.
10.times do
t = Time.now
marshal_equal(t, t.usec.to_s)
end
end
def test_time_subclass
marshal_equal(MyTime.new(10))
end
def test_time_ivar
o1 = Time.now
o1.instance_eval { @iv = 1 }
marshal_equal(o1) {|o| o.instance_eval { @iv }}
end
def test_true
marshal_equal(true)
end
def test_nil
marshal_equal(nil)
end
def test_share
o = [:share]
o1 = [o, o]
o2 = marshaltest(o1)
assert_same(o2.first, o2.last)
end
class CyclicRange < Range
def <=>(other); true; end
end
def test_range_cyclic
return unless CyclicRange.respond_to?(:allocate) # test for 1.8
o1 = CyclicRange.allocate
o1.instance_eval { initialize(o1, o1) }
o2 = marshaltest(o1)
assert_same(o2, o2.begin)
assert_same(o2, o2.end)
end
def test_singleton
o = Object.new
def o.m() end
assert_raises(TypeError) { marshaltest(o) }
o = Object.new
c = class << o
@v = 1
class C; self; end
end
assert_raises(TypeError) { marshaltest(o) }
assert_raises(TypeError) { marshaltest(c) }
assert_raises(TypeError) { marshaltest(ARGF) }
assert_raises(TypeError) { marshaltest(ENV) }
end
def test_extend
o = Object.new
o.extend Mod1
marshal_equal(o) { |obj| obj.kind_of? Mod1 }
o = Object.new
o.extend Mod1
o.extend Mod2
marshal_equal(o) {|obj| class << obj; ancestors end}
o = Object.new
o.extend Module.new
assert_raises(TypeError) { marshaltest(o) }
end
def test_extend_string
o = ""
o.extend Mod1
marshal_equal(o) { |obj| obj.kind_of? Mod1 }
o = ""
o.extend Mod1
o.extend Mod2
marshal_equal(o) {|obj| class << obj; ancestors end}
o = ""
o.extend Module.new
assert_raises(TypeError) { marshaltest(o) }
end
def test_anonymous
c = Class.new
assert_raises(TypeError) { marshaltest(c) }
o = c.new
assert_raises(TypeError) { marshaltest(o) }
m = Module.new
assert_raises(TypeError) { marshaltest(m) }
end
def test_string_empty
marshal_equal("")
end
def test_string_crlf
marshal_equal("\r\n")
end
def test_string_escape
marshal_equal("\0<;;>\1;;")
end
MyStruct2 = Struct.new(:a, :b)
if RUBY_VERSION < "1.8.0"
# Struct#== is not defined in ruby/1.6
class MyStruct2
def ==(rhs)
return true if __id__ == rhs.__id__
return false unless rhs.is_a?(::Struct)
return false if self.class != rhs.class
members.each do |member|
return false if self.__send__(member) != rhs.__send__(member)
end
return true
end
end
end
def test_struct_toplevel
o = MyStruct2.new(1,2)
marshal_equal(o)
end
end
Jump to Line
Something went wrong with that request. Please try again.