summaryrefslogtreecommitdiff
path: root/test/ruby/test_parse.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/ruby/test_parse.rb')
-rw-r--r--test/ruby/test_parse.rb523
1 files changed, 228 insertions, 295 deletions
diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index 1e909bce1b..b725634a38 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -13,24 +13,21 @@ class TestParse < Test::Unit::TestCase
$VERBOSE = @verbose
end
- def test_error_line
- assert_syntax_error('------,,', /\n\z/, 'Message to pipe should end with a newline')
- end
-
def test_else_without_rescue
- assert_syntax_error(<<-END, %r":#{__LINE__+2}: else without rescue"o, [__FILE__, __LINE__+1])
+ x = eval <<-END, nil, __FILE__, __LINE__+1
begin
else
42
end
END
+ assert_equal(42, x)
end
def test_alias_backref
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /can't make alias/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
alias $foo $1
- end;
+ END
end
end
@@ -85,10 +82,10 @@ class TestParse < Test::Unit::TestCase
assert_equal([42, 42], [o.Foo, o.Bar])
assert_equal([42, 42], [o::baz, o::qux])
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
$1 ||= t.foo 42
- end;
+ END
end
def t.bar(x); x + yield; end
@@ -153,65 +150,67 @@ class TestParse < Test::Unit::TestCase
end
def test_dynamic_constant_assignment
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /dynamic constant/) do
- begin;
+ assert_raise(SyntaxError) do
+ Object.new.instance_eval <<-END, __FILE__, __LINE__+1
def foo
self::FOO, self::BAR = 1, 2
::FOO, ::BAR = 1, 2
end
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
$1, $2 = 1, 2
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /dynamic constant/) do
- begin;
+ assert_raise(SyntaxError) do
+ Object.new.instance_eval <<-END, __FILE__, __LINE__+1
def foo
::FOO = 1
end
- end;
+ END
end
c = Class.new
c.freeze
- assert_valid_syntax("#{<<~"begin;"}\n#{<<~'end;'}") do
- begin;
+ assert_nothing_raised(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+ if false
c::FOO &= 1
::FOO &= 1
- end;
+ end
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
$1 &= 1
- end;
+ END
end
end
def test_class_module
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /must be CONSTANT/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
class foo; end
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /in method body/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def foo
class Foo; end
module Bar; end
end
- end;
+ END
end
- assert_valid_syntax("#{<<~"begin;"}\n#{<<~'end;'}") do
- begin;
+ assert_nothing_raised(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
class Foo 1; end
- end;
+ END
end
end
@@ -271,34 +270,37 @@ class TestParse < Test::Unit::TestCase
end
def test_bad_arg
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be a constant/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def foo(FOO); end
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be an instance variable/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def foo(@foo); end
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be a global variable/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def foo($foo); end
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be a class variable/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def foo(@@foo); end
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be an instance variable/) do
- begin;
- o.foo {|; @a| @a = 42 }
- end;
+ o = Object.new
+ def o.foo(*r); yield(*r); end
+
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+ o.foo 1 {|; @a| @a = 42 }
+ END
end
end
@@ -350,7 +352,6 @@ class TestParse < Test::Unit::TestCase
def test_words
assert_equal([], %W( ))
- assert_syntax_error('%w[abc', /unterminated list/)
end
def test_dstr
@@ -358,12 +359,11 @@ class TestParse < Test::Unit::TestCase
assert_equal("foo 1 bar", "foo #@@foo bar")
"1" =~ /(.)/
assert_equal("foo 1 bar", "foo #$1 bar")
- assert_equal('foo #@1 bar', eval('"foo #@1 bar"'))
end
def test_dstr_disallowed_variable
bug8375 = '[ruby-core:54885] [Bug #8375]'
- %w[@ @. @@ @@1 @@. $ $%].each do |src|
+ %w[@ @1 @. @@ @@1 @@. $ $%].each do |src|
src = '#'+src+' '
str = assert_nothing_raised(SyntaxError, "#{bug8375} #{src.dump}") do
break eval('"'+src+'"')
@@ -376,25 +376,23 @@ class TestParse < Test::Unit::TestCase
assert_nothing_raised { eval(':""') }
end
- def assert_disallowed_variable(type, noname, invalid)
- noname.each do |name|
- assert_syntax_error("proc{a = #{name} }", "`#{noname[0]}' without identifiers is not allowed as #{type} variable name")
- end
+ def assert_disallowed_variable(type, noname, *invalid)
+ assert_syntax_error(noname, "`#{noname}' without identifiers is not allowed as #{type} variable name")
invalid.each do |name|
- assert_syntax_error("proc {a = #{name} }", "`#{name}' is not allowed as #{type} variable name")
+ assert_syntax_error(name, "`#{name}' is not allowed as #{type} variable name")
end
end
def test_disallowed_instance_variable
- assert_disallowed_variable("an instance", %w[@ @.], %w[])
+ assert_disallowed_variable("an instance", *%w[@ @1 @.])
end
def test_disallowed_class_variable
- assert_disallowed_variable("a class", %w[@@ @@.], %w[@@1])
+ assert_disallowed_variable("a class", *%w[@@ @@1 @@.])
end
def test_disallowed_gloal_variable
- assert_disallowed_variable("a global", %w[$], %w[$%])
+ assert_disallowed_variable("a global", *%w[$ $%])
end
def test_arg2
@@ -432,56 +430,31 @@ class TestParse < Test::Unit::TestCase
end
def test_duplicate_argument
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", '') do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
1.times {|&b?| }
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
1.times {|a, a|}
- end;
+ END
end
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def foo(a, a); end
- end;
+ END
end
end
def test_define_singleton_error
- assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /singleton method for literals/) do
- begin;
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
def ("foo").foo; end
- end;
- end
- end
-
- def test_op_asgn1_with_block
- t = Object.new
- a = []
- blk = proc {|x| a << x }
- def t.[](_)
- yield(:aref)
- nil
- end
- def t.[]=(_, _)
- yield(:aset)
- end
- def t.dummy(_)
+ END
end
- eval <<-END, nil, __FILE__, __LINE__+1
- t[42, &blk] ||= 42
- END
- assert_equal([:aref, :aset], a)
- a.clear
- eval <<-END, nil, __FILE__, __LINE__+1
- t[42, &blk] ||= t.dummy 42 # command_asgn test
- END
- assert_equal([:aref, :aset], a)
- blk
end
def test_backquote
@@ -514,13 +487,13 @@ class TestParse < Test::Unit::TestCase
mesg = 'from the backslash through the invalid char'
e = assert_syntax_error('"\xg1"', /hex escape/)
- assert_equal(' ^~'"\n", e.message.lines.last, mesg)
+ assert_equal(' ^', e.message.lines.last, mesg)
e = assert_syntax_error('"\u{1234"', 'unterminated Unicode escape')
- assert_equal(' ^'"\n", e.message.lines.last, mesg)
+ assert_equal(' ^', e.message.lines.last, mesg)
e = assert_syntax_error('"\u{xxxx}"', 'invalid Unicode escape')
- assert_equal(' ^'"\n", e.message.lines.last, mesg)
+ assert_equal(' ^', e.message.lines.last, mesg)
e = assert_syntax_error('"\u{xxxx', 'Unicode escape')
assert_pattern_list([
@@ -531,14 +504,14 @@ class TestParse < Test::Unit::TestCase
/ \^/,
/\n/,
/.*: unterminated string.*\n.*\n/,
- / \^\n/,
+ / \^/,
], e.message)
e = assert_syntax_error('"\M1"', /escape character syntax/)
- assert_equal(' ^~~'"\n", e.message.lines.last, mesg)
+ assert_equal(' ^~~', e.message.lines.last, mesg)
e = assert_syntax_error('"\C1"', /escape character syntax/)
- assert_equal(' ^~~'"\n", e.message.lines.last, mesg)
+ assert_equal(' ^~~', e.message.lines.last, mesg)
src = '"\xD0\u{90'"\n""000000000000000000000000"
assert_syntax_error(src, /:#{__LINE__}: unterminated/o)
@@ -549,56 +522,27 @@ class TestParse < Test::Unit::TestCase
assert_equal("\x81", eval('"\C-\M-a"'))
assert_equal("\177", eval('"\c?"'))
-
- assert_warning(/use \\C-\\s/) {assert_equal("\x00", eval('"\C- "'))}
- assert_warning(/use \\M-\\s/) {assert_equal("\xa0", eval('"\M- "'))}
- assert_warning(/use \\M-\\C-\\s/) {assert_equal("\x80", eval('"\M-\C- "'))}
- assert_warning(/use \\C-\\M-\\s/) {assert_equal("\x80", eval('"\C-\M- "'))}
- assert_warning(/use \\t/) {assert_equal("\x09", eval("\"\\C-\t\""))}
- assert_warning(/use \\M-\\t/) {assert_equal("\x89", eval("\"\\M-\t\""))}
- assert_warning(/use \\M-\\t/) {assert_equal("\x89", eval("\"\\M-\\C-\t\""))}
- assert_warning(/use \\M-\\t/) {assert_equal("\x89", eval("\"\\C-\\M-\t\""))}
- assert_syntax_error("\"\\C-\x01\"", 'Invalid escape character syntax')
- assert_syntax_error("\"\\M-\x01\"", 'Invalid escape character syntax')
- assert_syntax_error("\"\\M-\\C-\x01\"", 'Invalid escape character syntax')
- assert_syntax_error("\"\\C-\\M-\x01\"", 'Invalid escape character syntax')
end
def test_question
- assert_syntax_error('?', /incomplete/)
- assert_syntax_error('? ', /unexpected/)
- assert_syntax_error("?\n", /unexpected/)
- assert_syntax_error("?\t", /unexpected/)
- assert_syntax_error("?\v", /unexpected/)
- assert_syntax_error("?\r", /unexpected/)
- assert_syntax_error("?\f", /unexpected/)
- assert_syntax_error(" ?a\x8a".force_encoding("utf-8"), /invalid multibyte/)
+ assert_raise(SyntaxError) { eval('?') }
+ assert_raise(SyntaxError) { eval('? ') }
+ assert_raise(SyntaxError) { eval("?\n") }
+ assert_raise(SyntaxError) { eval("?\t") }
+ assert_raise(SyntaxError) { eval("?\v") }
+ assert_raise(SyntaxError) { eval("?\r") }
+ assert_raise(SyntaxError) { eval("?\f") }
+ assert_raise(SyntaxError) { eval("?\f") }
+ assert_raise(SyntaxError) { eval(" ?a\x8a".force_encoding("utf-8")) }
assert_equal("\u{1234}", eval("?\u{1234}"))
assert_equal("\u{1234}", eval('?\u{1234}'))
- assert_equal("\u{1234}", eval('?\u1234'))
- assert_syntax_error('?\u{41 42}', 'Multiple codepoints at single character literal')
- e = assert_syntax_error('"#{?\u123}"', 'invalid Unicode escape')
- assert_not_match(/end-of-input/, e.message)
-
- assert_warning(/use ?\\C-\\s/) {assert_equal("\x00", eval('?\C- '))}
- assert_warning(/use ?\\M-\\s/) {assert_equal("\xa0", eval('?\M- '))}
- assert_warning(/use ?\\M-\\C-\\s/) {assert_equal("\x80", eval('?\M-\C- '))}
- assert_warning(/use ?\\C-\\M-\\s/) {assert_equal("\x80", eval('?\C-\M- '))}
- assert_warning(/use ?\\t/) {assert_equal("\x09", eval("?\\C-\t"))}
- assert_warning(/use ?\\M-\\t/) {assert_equal("\x89", eval("?\\M-\t"))}
- assert_warning(/use ?\\M-\\t/) {assert_equal("\x89", eval("?\\M-\\C-\t"))}
- assert_warning(/use ?\\M-\\t/) {assert_equal("\x89", eval("?\\C-\\M-\t"))}
- assert_syntax_error("?\\C-\x01", 'Invalid escape character syntax')
- assert_syntax_error("?\\M-\x01", 'Invalid escape character syntax')
- assert_syntax_error("?\\M-\\C-\x01", 'Invalid escape character syntax')
- assert_syntax_error("?\\C-\\M-\x01", 'Invalid escape character syntax')
end
def test_percent
assert_equal(:foo, eval('%s(foo)'))
- assert_syntax_error('%s', /unterminated quoted string/)
- assert_syntax_error('%ss', /unknown type/)
- assert_syntax_error('%z()', /unknown type/)
+ assert_raise(SyntaxError) { eval('%s') }
+ assert_raise(SyntaxError) { eval('%ss') }
+ assert_raise(SyntaxError) { eval('%z()') }
end
def test_symbol
@@ -617,21 +561,24 @@ class TestParse < Test::Unit::TestCase
assert_equal(:foobar, eval(':"foo\u{}bar"'))
assert_equal(:foobar, eval(':"foo\u{ }bar"'))
end
-
- assert_syntax_error(':@@', /is not allowed/)
- assert_syntax_error(':@@1', /is not allowed/)
- assert_syntax_error(':@', /is not allowed/)
- assert_syntax_error(':@1', /is not allowed/)
end
def test_parse_string
- assert_syntax_error("/\n", /unterminated/)
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+/
+ END
+ end
end
def test_here_document
x = nil
- assert_syntax_error("<\<FOO\n", /can't find string "FOO"/)
+ assert_raise(SyntaxError) do
+ eval %Q(
+<\<FOO
+ )
+ end
assert_nothing_raised(SyntaxError) do
x = eval %q(
@@ -642,11 +589,23 @@ FOO
end
assert_equal "\#$\n", x
- assert_syntax_error("<\<\"\n", /unterminated here document identifier/)
+ assert_raise(SyntaxError) do
+ eval %Q(
+<\<\"
+ )
+ end
- assert_syntax_error("<<``\n", /can't find string ""/)
+ assert_raise(SyntaxError) do
+ eval %q(
+<<``
+ )
+ end
- assert_syntax_error("<<--\n", /unexpected <</)
+ assert_raise(SyntaxError) do
+ eval %q(
+<<--
+ )
+ end
assert_nothing_raised(SyntaxError) do
x = eval %q(
@@ -709,22 +668,17 @@ x = __ENCODING__
end
def test_embedded_rd
- assert_valid_syntax("=begin\n""=end")
- assert_valid_syntax("=begin\n""=end\0")
- assert_valid_syntax("=begin\n""=end\C-d")
- assert_valid_syntax("=begin\n""=end\C-z")
- end
-
- def test_embedded_rd_error
- error = 'embedded document meets end of file'
- assert_syntax_error("=begin\n", error)
- assert_syntax_error("=begin", error)
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+=begin
+ END
+ end
end
def test_float
assert_equal(1.0/0, eval("1e10000"))
- assert_syntax_error('1_E', /trailing `_'/)
- assert_syntax_error('1E1E1', /unexpected constant/)
+ assert_raise(SyntaxError) { eval('1_E') }
+ assert_raise(SyntaxError) { eval('1E1E1') }
end
def test_global_variable
@@ -734,19 +688,17 @@ x = __ENCODING__
$test_parse_foobarbazqux = nil
assert_equal(nil, $&)
assert_equal(nil, eval('alias $& $preserve_last_match'))
- assert_syntax_error('a = $#', /as a global variable name\na = \$\#\n \^~$/)
+ assert_raise(SyntaxError) { eval('$#') }
end
def test_invalid_instance_variable
- pattern = /without identifiers is not allowed as an instance variable name/
- assert_syntax_error('@%', pattern)
- assert_syntax_error('@', pattern)
+ assert_raise(SyntaxError) { eval('@#') }
+ assert_raise(SyntaxError) { eval('@') }
end
def test_invalid_class_variable
- pattern = /without identifiers is not allowed as a class variable name/
- assert_syntax_error('@@%', pattern)
- assert_syntax_error('@@', pattern)
+ assert_raise(SyntaxError) { eval('@@1') }
+ assert_raise(SyntaxError) { eval('@@') }
end
def test_invalid_char
@@ -766,23 +718,56 @@ x = __ENCODING__
end
def test_unassignable
- assert_syntax_error(%q(self = 1), /Can't change the value of self/)
- assert_syntax_error(%q(nil = 1), /Can't assign to nil/)
- assert_syntax_error(%q(true = 1), /Can't assign to true/)
- assert_syntax_error(%q(false = 1), /Can't assign to false/)
- assert_syntax_error(%q(__FILE__ = 1), /Can't assign to __FILE__/)
- assert_syntax_error(%q(__LINE__ = 1), /Can't assign to __LINE__/)
- assert_syntax_error(%q(__ENCODING__ = 1), /Can't assign to __ENCODING__/)
- assert_syntax_error("def foo; FOO = 1; end", /dynamic constant assignment/)
- assert_syntax_error("x, true", /Can't assign to true/)
+ assert_raise(SyntaxError) do
+ eval %q(self = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval %q(nil = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval %q(true = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval %q(false = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval %q(__FILE__ = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval %q(__LINE__ = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval %q(__ENCODING__ = 1)
+ end
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+ def foo
+ FOO = 1
+ end
+ END
+ end
+ assert_raise(SyntaxError) do
+ eval "#{<<~"begin;"}\n#{<<~'end;'}", nil, __FILE__, __LINE__+1
+ begin;
+ x, true
+ end;
+ end
end
def test_block_dup
- assert_syntax_error("foo(&proc{}) {}", /both block arg and actual block/)
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+ foo(&proc{}) {}
+ END
+ end
end
def test_set_backref
- assert_syntax_error("$& = 1", /Can't set variable/)
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+ $& = 1
+ END
+ end
end
def test_arg_concat
@@ -800,24 +785,32 @@ x = __ENCODING__
end
def test_void_expr_stmts_value
+ # This test checks if void contexts are warned correctly.
+ # Thus, warnings MUST NOT be suppressed.
+ $VERBOSE = true
+ stderr = $stderr
+ $stderr = StringIO.new("")
x = 1
- useless_use = /useless use/
- unused = /unused/
- assert_nil assert_warning(useless_use) {eval("x; nil")}
- assert_nil assert_warning(useless_use) {eval("1+1; nil")}
- assert_nil assert_warning('') {eval("1.+(1); nil")}
- assert_nil assert_warning(useless_use) {eval("TestParse; nil")}
- assert_nil assert_warning(useless_use) {eval("::TestParse; nil")}
- assert_nil assert_warning(useless_use) {eval("x..x; nil")}
- assert_nil assert_warning(useless_use) {eval("x...x; nil")}
- assert_nil assert_warning(unused) {eval("self; nil")}
- assert_nil assert_warning(unused) {eval("nil; nil")}
- assert_nil assert_warning(unused) {eval("true; nil")}
- assert_nil assert_warning(unused) {eval("false; nil")}
- assert_nil assert_warning(useless_use) {eval("defined?(1); nil")}
+ assert_nil eval("x; nil")
+ assert_nil eval("1+1; nil")
+ assert_nil eval("1.+(1); nil")
+ assert_nil eval("TestParse; nil")
+ assert_nil eval("::TestParse; nil")
+ assert_nil eval("x..x; nil")
+ assert_nil eval("x...x; nil")
+ assert_nil eval("self; nil")
+ assert_nil eval("nil; nil")
+ assert_nil eval("true; nil")
+ assert_nil eval("false; nil")
+ assert_nil eval("defined?(1); nil")
assert_equal 1, x
- assert_syntax_error("1; next; 2", /Invalid next/)
+ assert_raise(SyntaxError) do
+ eval %q(1; next; 2)
+ end
+
+ assert_equal(13, $stderr.string.lines.to_a.size)
+ $stderr = stderr
end
def test_assign_in_conditional
@@ -874,7 +867,11 @@ x = __ENCODING__
end
def test_no_blockarg
- assert_syntax_error("yield(&:+)", /block argument should not be given/)
+ assert_raise(SyntaxError) do
+ eval <<-END, nil, __FILE__, __LINE__+1
+ yield(&:+)
+ END
+ end
end
def test_method_block_location
@@ -891,8 +888,10 @@ x = __ENCODING__
assert_equal(expected, actual, bug5614)
end
- def test_no_shadowing_variable_warning
- assert_no_warning(/shadowing outer local variable/) {eval("a=1; tap {|a|}")}
+ def test_shadowing_variable
+ assert_warning(/shadowing outer local variable/) {eval("a=1; tap {|a|}")}
+ a = "\u{3042}"
+ assert_warning(/#{a}/o) {eval("#{a}=1; tap {|#{a}|}")}
end
def test_unused_variable
@@ -900,12 +899,10 @@ x = __ENCODING__
assert_warning(/assigned but unused variable/) {o.instance_eval("def foo; a=1; nil; end")}
assert_warning(/assigned but unused variable/) {o.instance_eval("def bar; a=1; a(); end")}
a = "\u{3042}"
- assert_warning(/#{a}/) {o.instance_eval("def foo0; #{a}=1; nil; end")}
- assert_warning(/assigned but unused variable/) {o.instance_eval("def foo1; tap {a=1; a()}; end")}
- assert_warning('') {o.instance_eval("def bar1; a=a=1; nil; end")}
- assert_warning(/assigned but unused variable/) {o.instance_eval("def bar2; a, = 1, 2; end")}
- assert_warning('') {o.instance_eval("def marg1(a); nil; end")}
- assert_warning('') {o.instance_eval("def marg2((a)); nil; end")}
+ assert_warning(/#{a}/) {o.instance_eval("def foo; #{a}=1; nil; end")}
+ o = Object.new
+ assert_warning(/assigned but unused variable/) {o.instance_eval("def foo; tap {a=1; a()}; end")}
+ assert_warning('') {o.instance_eval("def bar; a=a=1; nil; end")}
end
def test_named_capture_conflict
@@ -1046,26 +1043,35 @@ x = __ENCODING__
end
def test_unexpected_token_error
- assert_syntax_error('"x"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', /unexpected/)
+ assert_raise(SyntaxError) do
+ eval('"x"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+ end
end
def test_unexpected_token_after_numeric
- assert_syntax_error('0000xyz', /^ \^~~\Z/)
- assert_syntax_error('1.2i1.1', /^ \^~~\Z/)
- assert_syntax_error('1.2.3', /^ \^~\Z/)
+ assert_raise_with_message(SyntaxError, /^ \^~~\z/) do
+ eval('0000xyz')
+ end
+ assert_raise_with_message(SyntaxError, /^ \^~~\z/) do
+ eval('1.2i1.1')
+ end
end
def test_truncated_source_line
- e = assert_syntax_error("'0123456789012345678901234567890123456789' abcdefghijklmnopqrstuvwxyz0123456789 0123456789012345678901234567890123456789",
- /unexpected local variable or method/)
+ e = assert_raise_with_message(SyntaxError, /unexpected tIDENTIFIER/) do
+ eval("'0123456789012345678901234567890123456789' abcdefghijklmnopqrstuvwxyz0123456789 0123456789012345678901234567890123456789")
+ end
line = e.message.lines[1]
assert_operator(line, :start_with?, "...")
assert_operator(line, :end_with?, "...\n")
end
def test_unterminated_regexp_error
- e = assert_syntax_error("/x", /unterminated regexp meets end of file/)
- assert_not_match(/unexpected tSTRING_END/, e.message)
+ e = assert_raise(SyntaxError) do
+ eval("/x")
+ end.message
+ assert_match(/unterminated regexp meets end of file/, e)
+ assert_not_match(/unexpected tSTRING_END/, e)
end
def test_lparenarg
@@ -1075,8 +1081,7 @@ x = __ENCODING__
end
o.instance_eval {i (-1.3).abs}
assert_equal(1.3, o.x)
- o.i(nil)
- o.instance_eval {i = 0; i (-1.3).abs; i}
+ o.instance_eval {i = 0; i (-1.3).abs}
assert_equal(1.3, o.x)
end
@@ -1085,85 +1090,13 @@ x = __ENCODING__
$VERBOSE = true
x = 1
eval("if false; 0 < x < 2; end")
- x
end
end
- def test_eof
- assert_equal(42, eval("42\0""end"))
- assert_equal(42, eval("42\C-d""end"))
- assert_equal(42, eval("42\C-z""end"))
- end
-
def test_eof_in_def
- assert_syntax_error("def m\n\0""end", /unexpected/)
- assert_syntax_error("def m\n\C-d""end", /unexpected/)
- assert_syntax_error("def m\n\C-z""end", /unexpected/)
- end
-
- def test_location_of_invalid_token
- assert_syntax_error('class xxx end', /^ \^~~\Z/)
- end
-
- def test_whitespace_warning
- assert_syntax_error("\\foo", /backslash/)
- assert_syntax_error("\\ ", /escaped space/)
- assert_syntax_error("\\\t", /escaped horizontal tab/)
- assert_syntax_error("\\\f", /escaped form feed/)
- assert_syntax_error("\\\r", /escaped carriage return/)
- assert_warn(/middle of line/) {eval(" \r ")}
- assert_syntax_error("\\\v", /escaped vertical tab/)
- end
-
- def test_command_def_cmdarg
- assert_valid_syntax("\n#{<<~"begin;"}\n#{<<~'end;'}")
- begin;
- m def x(); end
- 1.tap do end
- end;
- end
-
- NONASCII_CONSTANTS = [
- *%W"\u{00de} \u{00C0}".flat_map {|c| [c, c.encode("iso-8859-15")]},
- "\u{1c4}", "\u{1f2}", "\u{1f88}", "\u{370}",
- *%W"\u{391} \u{ff21}".flat_map {|c| [c, c.encode("cp932"), c.encode("euc-jp")]},
- ]
-
- def assert_nonascii_const
- assert_all_assertions_foreach("NONASCII_CONSTANTS", *NONASCII_CONSTANTS) do |n|
- m = Module.new
- assert_not_operator(m, :const_defined?, n)
- assert_raise_with_message(NameError, /uninitialized/) do
- m.const_get(n)
- end
- assert_nil(eval("defined?(m::#{n})"))
-
- v = yield m, n
-
- assert_operator(m, :const_defined?, n)
- assert_equal("constant", eval("defined?(m::#{n})"))
- assert_same(v, m.const_get(n))
-
- m.__send__(:remove_const, n)
- assert_not_operator(m, :const_defined?, n)
- assert_nil(eval("defined?(m::#{n})"))
- end
- end
-
- def test_nonascii_const_set
- assert_nonascii_const do |m, n|
- m.const_set(n, 42)
- end
- end
-
- def test_nonascii_constant
- assert_nonascii_const do |m, n|
- m.module_eval("class #{n}; self; end")
- end
- end
-
- def test_cdmarg_after_command_args_and_tlbrace_arg
- assert_valid_syntax('let () { m(a) do; end }')
+ assert_raise(SyntaxError) { eval("def m\n\0""end") }
+ assert_raise(SyntaxError) { eval("def m\n\C-d""end") }
+ assert_raise(SyntaxError) { eval("def m\n\C-z""end") }
end
def test_void_value_in_command_rhs
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-07 14:00:04 +0000