mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
93278f2387
trying the call. based on a patch from Yehuda Katz in [ruby-core:27219]. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@26124 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
564 lines
13 KiB
Ruby
564 lines
13 KiB
Ruby
require 'test/unit'
|
|
require_relative 'envutil'
|
|
|
|
class TestObject < Test::Unit::TestCase
|
|
def setup
|
|
@verbose = $VERBOSE
|
|
$VERBOSE = nil
|
|
end
|
|
|
|
def teardown
|
|
$VERBOSE = @verbose
|
|
end
|
|
|
|
def test_dup
|
|
assert_raise(TypeError) { 1.dup }
|
|
assert_raise(TypeError) { true.dup }
|
|
assert_raise(TypeError) { nil.dup }
|
|
|
|
assert_raise(TypeError) do
|
|
Object.new.instance_eval { initialize_copy(1) }
|
|
end
|
|
end
|
|
|
|
def test_instance_of
|
|
assert_raise(TypeError) { 1.instance_of?(1) }
|
|
end
|
|
|
|
def test_kind_of
|
|
assert_raise(TypeError) { 1.kind_of?(1) }
|
|
end
|
|
|
|
def test_taint_frozen_obj
|
|
o = Object.new
|
|
o.freeze
|
|
assert_raise(RuntimeError) { o.taint }
|
|
|
|
o = Object.new
|
|
o.taint
|
|
o.freeze
|
|
assert_raise(RuntimeError) { o.untaint }
|
|
end
|
|
|
|
def test_freeze_under_safe_4
|
|
o = Object.new
|
|
assert_raise(SecurityError) do
|
|
Thread.new do
|
|
$SAFE = 4
|
|
o.freeze
|
|
end.join
|
|
end
|
|
end
|
|
|
|
def test_freeze_immediate
|
|
assert_equal(false, 1.frozen?)
|
|
1.freeze
|
|
assert_equal(true, 1.frozen?)
|
|
assert_equal(false, 2.frozen?)
|
|
end
|
|
|
|
def test_nil_to_f
|
|
assert_equal(0.0, nil.to_f)
|
|
end
|
|
|
|
def test_not
|
|
assert_equal(false, Object.new.send(:!))
|
|
assert_equal(true, nil.send(:!))
|
|
end
|
|
|
|
def test_true_and
|
|
assert_equal(true, true & true)
|
|
assert_equal(true, true & 1)
|
|
assert_equal(false, true & false)
|
|
assert_equal(false, true & nil)
|
|
end
|
|
|
|
def test_true_or
|
|
assert_equal(true, true | true)
|
|
assert_equal(true, true | 1)
|
|
assert_equal(true, true | false)
|
|
assert_equal(true, true | nil)
|
|
end
|
|
|
|
def test_true_xor
|
|
assert_equal(false, true ^ true)
|
|
assert_equal(false, true ^ 1)
|
|
assert_equal(true, true ^ false)
|
|
assert_equal(true, true ^ nil)
|
|
end
|
|
|
|
def test_false_and
|
|
assert_equal(false, false & true)
|
|
assert_equal(false, false & 1)
|
|
assert_equal(false, false & false)
|
|
assert_equal(false, false & nil)
|
|
end
|
|
|
|
def test_false_or
|
|
assert_equal(true, false | true)
|
|
assert_equal(true, false | 1)
|
|
assert_equal(false, false | false)
|
|
assert_equal(false, false | nil)
|
|
end
|
|
|
|
def test_false_xor
|
|
assert_equal(true, false ^ true)
|
|
assert_equal(true, false ^ 1)
|
|
assert_equal(false, false ^ false)
|
|
assert_equal(false, false ^ nil)
|
|
end
|
|
|
|
def test_methods
|
|
o = Object.new
|
|
a1 = o.methods
|
|
a2 = o.methods(false)
|
|
|
|
def o.foo; end
|
|
|
|
assert_equal([:foo], o.methods(true) - a1)
|
|
assert_equal([:foo], o.methods(false) - a2)
|
|
end
|
|
|
|
def test_methods2
|
|
c0 = Class.new
|
|
c1 = Class.new(c0)
|
|
c1.module_eval do
|
|
public ; def foo; end
|
|
protected; def bar; end
|
|
private ; def baz; end
|
|
end
|
|
c2 = Class.new(c1)
|
|
c2.module_eval do
|
|
public ; def foo2; end
|
|
protected; def bar2; end
|
|
private ; def baz2; end
|
|
end
|
|
|
|
o0 = c0.new
|
|
o2 = c2.new
|
|
|
|
assert_equal([:baz, :baz2], (o2.private_methods - o0.private_methods).sort)
|
|
assert_equal([:baz2], (o2.private_methods(false) - o0.private_methods(false)).sort)
|
|
|
|
assert_equal([:bar, :bar2], (o2.protected_methods - o0.protected_methods).sort)
|
|
assert_equal([:bar2], (o2.protected_methods(false) - o0.protected_methods(false)).sort)
|
|
|
|
assert_equal([:foo, :foo2], (o2.public_methods - o0.public_methods).sort)
|
|
assert_equal([:foo2], (o2.public_methods(false) - o0.public_methods(false)).sort)
|
|
end
|
|
|
|
def test_instance_variable_get
|
|
o = Object.new
|
|
o.instance_eval { @foo = :foo }
|
|
assert_equal(:foo, o.instance_variable_get(:@foo))
|
|
assert_equal(nil, o.instance_variable_get(:@bar))
|
|
assert_raise(NameError) { o.instance_variable_get(:foo) }
|
|
end
|
|
|
|
def test_instance_variable_set
|
|
o = Object.new
|
|
o.instance_variable_set(:@foo, :foo)
|
|
assert_equal(:foo, o.instance_eval { @foo })
|
|
assert_raise(NameError) { o.instance_variable_set(:foo, 1) }
|
|
end
|
|
|
|
def test_instance_variable_defined
|
|
o = Object.new
|
|
o.instance_eval { @foo = :foo }
|
|
assert_equal(true, o.instance_variable_defined?(:@foo))
|
|
assert_equal(false, o.instance_variable_defined?(:@bar))
|
|
assert_raise(NameError) { o.instance_variable_defined?(:foo) }
|
|
end
|
|
|
|
def test_remove_instance_variable
|
|
o = Object.new
|
|
o.instance_eval { @foo = :foo }
|
|
o.instance_eval { remove_instance_variable(:@foo) }
|
|
assert_equal(false, o.instance_variable_defined?(:@foo))
|
|
end
|
|
|
|
def test_convert_type
|
|
o = Object.new
|
|
def o.to_s; 1; end
|
|
assert_raise(TypeError) { String(o) }
|
|
end
|
|
|
|
def test_check_convert_type
|
|
o = Object.new
|
|
def o.to_a; 1; end
|
|
assert_raise(TypeError) { Array(o) }
|
|
end
|
|
|
|
def test_to_integer
|
|
o = Object.new
|
|
def o.to_i; nil; end
|
|
assert_raise(TypeError) { Integer(o) }
|
|
end
|
|
|
|
class MyInteger
|
|
def initialize(n); @num = n; end
|
|
def to_int; @num; end
|
|
def <=>(n); @num <=> n.to_int; end
|
|
def <=(n); @num <= n.to_int; end
|
|
def +(n); MyInteger.new(@num + n.to_int); end
|
|
end
|
|
|
|
def test_check_to_integer
|
|
o1 = MyInteger.new(1)
|
|
o9 = MyInteger.new(9)
|
|
n = 0
|
|
Range.new(o1, o9).step(2) {|x| n += x.to_int }
|
|
assert_equal(1+3+5+7+9, n)
|
|
end
|
|
|
|
def test_add_method_under_safe4
|
|
o = Object.new
|
|
assert_raise(SecurityError) do
|
|
Thread.new do
|
|
$SAFE = 4
|
|
def o.foo
|
|
end
|
|
end.join
|
|
end
|
|
end
|
|
|
|
def test_redefine_method_under_verbose
|
|
assert_in_out_err([], <<-INPUT, %w(2), /warning: method redefined; discarding old foo$/)
|
|
$VERBOSE = true
|
|
o = Object.new
|
|
def o.foo; 1; end
|
|
def o.foo; 2; end
|
|
p o.foo
|
|
INPUT
|
|
end
|
|
|
|
def test_redefine_method_which_may_case_serious_problem
|
|
assert_in_out_err([], <<-INPUT, [], /warning: redefining `object_id' may cause serious problems$/)
|
|
$VERBOSE = false
|
|
def (Object.new).object_id; end
|
|
INPUT
|
|
|
|
assert_in_out_err([], <<-INPUT, [], /warning: redefining `__send__' may cause serious problems$/)
|
|
$VERBOSE = false
|
|
def (Object.new).__send__; end
|
|
INPUT
|
|
end
|
|
|
|
def test_remove_method
|
|
assert_raise(SecurityError) do
|
|
Thread.new do
|
|
$SAFE = 4
|
|
Object.instance_eval { remove_method(:foo) }
|
|
end.join
|
|
end
|
|
|
|
assert_raise(SecurityError) do
|
|
Thread.new do
|
|
$SAFE = 4
|
|
Class.instance_eval { remove_method(:foo) }
|
|
end.join
|
|
end
|
|
|
|
c = Class.new
|
|
c.freeze
|
|
assert_raise(RuntimeError) do
|
|
c.instance_eval { remove_method(:foo) }
|
|
end
|
|
|
|
c = Class.new do
|
|
def meth1; "meth" end
|
|
end
|
|
d = Class.new(c) do
|
|
alias meth2 meth1
|
|
end
|
|
o1 = c.new
|
|
assert_respond_to(o1, :meth1)
|
|
assert_equal("meth", o1.meth1)
|
|
o2 = d.new
|
|
assert_respond_to(o2, :meth1)
|
|
assert_equal("meth", o2.meth1)
|
|
assert_respond_to(o2, :meth2)
|
|
assert_equal("meth", o2.meth2)
|
|
d.class_eval do
|
|
remove_method :meth2
|
|
end
|
|
bug2202 = '[ruby-core:26074]'
|
|
assert_raise(NoMethodError, bug2202) {o2.meth2}
|
|
|
|
%w(object_id __send__ initialize).each do |m|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), /warning: removing `#{m}' may cause serious problems$/)
|
|
$VERBOSE = false
|
|
begin
|
|
Class.new.instance_eval { remove_method(:#{m}) }
|
|
rescue NameError
|
|
p :ok
|
|
end
|
|
INPUT
|
|
end
|
|
end
|
|
|
|
def test_method_missing
|
|
assert_raise(ArgumentError) do
|
|
1.instance_eval { method_missing }
|
|
end
|
|
|
|
c = Class.new
|
|
c.class_eval do
|
|
protected
|
|
def foo; end
|
|
end
|
|
assert_raise(NoMethodError) do
|
|
c.new.foo
|
|
end
|
|
|
|
assert_raise(NoMethodError) do
|
|
1.instance_eval { method_missing(:method_missing) }
|
|
end
|
|
|
|
c.class_eval do
|
|
undef_method(:method_missing)
|
|
end
|
|
|
|
assert_raise(ArgumentError) do
|
|
c.new.method_missing
|
|
end
|
|
|
|
bug2494 = '[ruby-core:27219]'
|
|
c = Class.new do
|
|
def method_missing(meth, *args)
|
|
super
|
|
end
|
|
end
|
|
b = c.new
|
|
foo rescue nil
|
|
assert_nothing_raised(bug2494) {[b].flatten}
|
|
end
|
|
|
|
def test_respond_to_missing
|
|
c = Class.new do
|
|
def respond_to_missing?(id, priv=false)
|
|
if id == :foobar
|
|
true
|
|
else
|
|
false
|
|
end
|
|
end
|
|
def method_missing(id,*args)
|
|
if id == :foobar
|
|
return [:foo, *args]
|
|
else
|
|
super
|
|
end
|
|
end
|
|
end
|
|
|
|
foo = c.new
|
|
assert_equal([:foo], foo.foobar);
|
|
assert_equal([:foo, 1], foo.foobar(1));
|
|
assert_equal([:foo, 1, 2, 3, 4, 5], foo.foobar(1, 2, 3, 4, 5));
|
|
assert(foo.respond_to?(:foobar))
|
|
assert_equal(false, foo.respond_to?(:foobarbaz))
|
|
assert_raise(NoMethodError) do
|
|
foo.foobarbaz
|
|
end
|
|
|
|
foobar = foo.method(:foobar)
|
|
assert_equal(-1, foobar.arity);
|
|
assert_equal([:foo], foobar.call);
|
|
assert_equal([:foo, 1], foobar.call(1));
|
|
assert_equal([:foo, 1, 2, 3, 4, 5], foobar.call(1, 2, 3, 4, 5));
|
|
assert_equal(foobar, foo.method(:foobar))
|
|
assert_not_equal(foobar, c.new.method(:foobar))
|
|
|
|
c = Class.new(c)
|
|
assert_equal(false, c.method_defined?(:foobar))
|
|
assert_raise(NameError, '[ruby-core:25748]') do
|
|
c.instance_method(:foobar)
|
|
end
|
|
|
|
m = Module.new
|
|
assert_equal(false, m.method_defined?(:foobar))
|
|
assert_raise(NameError, '[ruby-core:25748]') do
|
|
m.instance_method(:foobar)
|
|
end
|
|
end
|
|
|
|
def test_send_with_no_arguments
|
|
assert_raise(ArgumentError) { 1.send }
|
|
end
|
|
|
|
def test_no_superclass_method
|
|
bug2312 = '[ruby-dev:39581]'
|
|
|
|
o = Object.new
|
|
e = assert_raise(NoMethodError) {
|
|
o.method(:__send__).call(:never_defined_test_no_superclass_method)
|
|
}
|
|
m1 = e.message
|
|
assert_no_match(/no superclass method/, m1, bug2312)
|
|
e = assert_raise(NoMethodError) {
|
|
o.method(:__send__).call(:never_defined_test_no_superclass_method)
|
|
}
|
|
assert_equal(m1, e.message, bug2312)
|
|
e = assert_raise(NoMethodError) {
|
|
o.never_defined_test_no_superclass_method
|
|
}
|
|
assert_equal(m1, e.message, bug2312)
|
|
end
|
|
|
|
def test_superclass_method
|
|
bug2312 = '[ruby-dev:39581]'
|
|
assert_in_out_err(["-e", "module Enumerable;undef min;end; (1..2).min{}"],
|
|
"", [], /no superclass method/, bug2312)
|
|
end
|
|
|
|
def test_specific_eval_with_wrong_arguments
|
|
assert_raise(ArgumentError) do
|
|
1.instance_eval("foo") { foo }
|
|
end
|
|
|
|
assert_raise(ArgumentError) do
|
|
1.instance_eval
|
|
end
|
|
|
|
assert_raise(ArgumentError) do
|
|
1.instance_eval("", 1, 1, 1)
|
|
end
|
|
end
|
|
|
|
class InstanceExec
|
|
INSTANCE_EXEC = 123
|
|
end
|
|
|
|
def test_instance_exec
|
|
x = 1.instance_exec(42) {|a| self + a }
|
|
assert_equal(43, x)
|
|
|
|
x = "foo".instance_exec("bar") {|a| self + a }
|
|
assert_equal("foobar", x)
|
|
|
|
assert_raise(NameError) do
|
|
InstanceExec.new.instance_exec { INSTANCE_EXEC }
|
|
end
|
|
end
|
|
|
|
def test_extend
|
|
assert_raise(ArgumentError) do
|
|
1.extend
|
|
end
|
|
end
|
|
|
|
def test_untrusted
|
|
obj = lambda {
|
|
$SAFE = 4
|
|
x = Object.new
|
|
x.instance_eval { @foo = 1 }
|
|
x
|
|
}.call
|
|
assert_equal(true, obj.untrusted?)
|
|
assert_equal(true, obj.tainted?)
|
|
|
|
x = Object.new
|
|
assert_equal(false, x.untrusted?)
|
|
assert_raise(SecurityError) do
|
|
lambda {
|
|
$SAFE = 4
|
|
x.instance_eval { @foo = 1 }
|
|
}.call
|
|
end
|
|
|
|
x = Object.new
|
|
x.taint
|
|
assert_raise(SecurityError) do
|
|
lambda {
|
|
$SAFE = 4
|
|
x.instance_eval { @foo = 1 }
|
|
}.call
|
|
end
|
|
|
|
x.untrust
|
|
assert_equal(true, x.untrusted?)
|
|
assert_nothing_raised do
|
|
lambda {
|
|
$SAFE = 4
|
|
x.instance_eval { @foo = 1 }
|
|
}.call
|
|
end
|
|
|
|
x.trust
|
|
assert_equal(false, x.untrusted?)
|
|
assert_raise(SecurityError) do
|
|
lambda {
|
|
$SAFE = 4
|
|
x.instance_eval { @foo = 1 }
|
|
}.call
|
|
end
|
|
|
|
a = Object.new
|
|
a.untrust
|
|
assert_equal(true, a.untrusted?)
|
|
b = a.dup
|
|
assert_equal(true, b.untrusted?)
|
|
c = a.clone
|
|
assert_equal(true, c.untrusted?)
|
|
|
|
a = Object.new
|
|
b = lambda {
|
|
$SAFE = 4
|
|
a.dup
|
|
}.call
|
|
assert_equal(true, b.untrusted?)
|
|
|
|
a = Object.new
|
|
b = lambda {
|
|
$SAFE = 4
|
|
a.clone
|
|
}.call
|
|
assert_equal(true, b.untrusted?)
|
|
end
|
|
|
|
def test_to_s
|
|
x = Object.new
|
|
x.taint
|
|
x.untrust
|
|
s = x.to_s
|
|
assert_equal(true, s.untrusted?)
|
|
assert_equal(true, s.tainted?)
|
|
end
|
|
|
|
def test_exec_recursive
|
|
Thread.current[:__recursive_key__] = nil
|
|
a = [[]]
|
|
a.inspect
|
|
|
|
assert_nothing_raised do
|
|
-> do
|
|
$SAFE = 4
|
|
begin
|
|
a.hash
|
|
rescue ArgumentError
|
|
end
|
|
end.call
|
|
end
|
|
|
|
-> do
|
|
assert_nothing_raised do
|
|
$SAFE = 4
|
|
a.inspect
|
|
end
|
|
end.call
|
|
|
|
-> do
|
|
o = Object.new
|
|
def o.to_ary(x); end
|
|
def o.==(x); $SAFE = 4; false; end
|
|
a = [[o]]
|
|
b = []
|
|
b << b
|
|
|
|
assert_nothing_raised do
|
|
b == a
|
|
end
|
|
end.call
|
|
end
|
|
end
|