Prefer assert_syntax_error and assert_valid_syntax

2 files changed, 143 insertions, 268 deletions

diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index b4b03467f6..ee5f815fd6 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -27,10 +27,10 @@ class TestParse < Test::Unit::TestCase
   end
 
   def test_alias_backref
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /can't make alias/) do
+      begin;
         alias $foo $1
-      END
+      end;
     end
   end
 
@@ -85,10 +85,10 @@ class TestParse < Test::Unit::TestCase
     assert_equal([42, 42], [o.Foo, o.Bar])
     assert_equal([42, 42], [o::baz, o::qux])
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
+      begin;
         $1 ||= t.foo 42
-      END
+      end;
     end
 
     def t.bar(x); x + yield; end
@@ -153,67 +153,65 @@ class TestParse < Test::Unit::TestCase
   end
 
   def test_dynamic_constant_assignment
-    assert_raise(SyntaxError) do
-      Object.new.instance_eval <<-END, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /dynamic constant/) do
+      begin;
         def foo
           self::FOO, self::BAR = 1, 2
           ::FOO, ::BAR = 1, 2
         end
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
+      begin;
         $1, $2 = 1, 2
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      Object.new.instance_eval <<-END, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /dynamic constant/) do
+      begin;
         def foo
           ::FOO = 1
         end
-      END
+      end;
     end
 
     c = Class.new
     c.freeze
-    assert_nothing_raised(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
-      if false
+    assert_valid_syntax("#{<<~"begin;"}\n#{<<~'end;'}") do
+      begin;
         c::FOO &= 1
         ::FOO &= 1
-      end
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
+      begin;
         $1 &= 1
-      END
+      end;
     end
   end
 
   def test_class_module
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /must be CONSTANT/) do
+      begin;
         class foo; end
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /in method body/) do
+      begin;
         def foo
           class Foo; end
           module Bar; end
         end
-      END
+      end;
     end
 
-    assert_nothing_raised(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_valid_syntax("#{<<~"begin;"}\n#{<<~'end;'}") do
+      begin;
         class Foo 1; end
-      END
+      end;
     end
   end
 
@@ -273,37 +271,34 @@ class TestParse < Test::Unit::TestCase
   end
 
   def test_bad_arg
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be a constant/) do
+      begin;
         def foo(FOO); end
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be an instance variable/) do
+      begin;
         def foo(@foo); end
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be a global variable/) do
+      begin;
         def foo($foo); end
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be a class variable/) do
+      begin;
         def foo(@@foo); end
-      END
+      end;
     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
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be an instance variable/) do
+      begin;
+        o.foo {|; @a| @a = 42 }
+      end;
     end
   end
 
@@ -436,30 +431,30 @@ class TestParse < Test::Unit::TestCase
   end
 
   def test_duplicate_argument
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", '') do
+      begin;
         1.times {|&b?| }
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument/) do
+      begin;
         1.times {|a, a|}
-      END
+      end;
     end
 
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument/) do
+      begin;
         def foo(a, a); end
-      END
+      end;
     end
   end
 
   def test_define_singleton_error
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /singleton method for literals/) do
+      begin;
         def ("foo").foo; end
-      END
+      end;
     end
   end
 
@@ -569,15 +564,14 @@ class TestParse < Test::Unit::TestCase
   end
 
   def test_question
-    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_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_equal("\u{1234}", eval("?\u{1234}"))
     assert_equal("\u{1234}", eval('?\u{1234}'))
     assert_equal("\u{1234}", eval('?\u1234'))
@@ -601,9 +595,9 @@ class TestParse < Test::Unit::TestCase
 
   def test_percent
     assert_equal(:foo, eval('%s(foo)'))
-    assert_raise(SyntaxError) { eval('%s') }
-    assert_raise(SyntaxError) { eval('%ss') }
-    assert_raise(SyntaxError) { eval('%z()') }
+    assert_syntax_error('%s', /unterminated quoted string/)
+    assert_syntax_error('%ss', /unknown type/)
+    assert_syntax_error('%z()', /unknown type/)
   end
 
   def test_symbol
@@ -630,21 +624,13 @@ class TestParse < Test::Unit::TestCase
   end
 
   def test_parse_string
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
-/
-      END
-    end
+    assert_syntax_error("/\n", /unterminated/)
   end
 
   def test_here_document
     x = nil
 
-    assert_raise(SyntaxError) do
-      eval %Q(
-<\<FOO
-      )
-    end
+    assert_syntax_error("<\<FOO\n", /can't find string "FOO"/)
 
     assert_nothing_raised(SyntaxError) do
       x = eval %q(
@@ -655,23 +641,11 @@ FOO
     end
     assert_equal "\#$\n", x
 
-    assert_raise(SyntaxError) do
-      eval %Q(
-<\<\"
-      )
-    end
+    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_nothing_raised(SyntaxError) do
       x = eval %q(
@@ -734,17 +708,13 @@ x = __ENCODING__
   end
 
   def test_embedded_rd
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
-=begin
-      END
-    end
+    assert_valid_syntax("=begin\n""=end")
   end
 
   def test_float
     assert_equal(1.0/0, eval("1e10000"))
-    assert_raise(SyntaxError) { eval('1_E') }
-    assert_raise(SyntaxError) { eval('1E1E1') }
+    assert_syntax_error('1_E', /trailing `_'/)
+    assert_syntax_error('1E1E1', /unexpected constant/)
   end
 
   def test_global_variable
@@ -754,21 +724,19 @@ x = __ENCODING__
     $test_parse_foobarbazqux = nil
     assert_equal(nil, $&)
     assert_equal(nil, eval('alias $& $preserve_last_match'))
-    assert_raise_with_message(SyntaxError, /as a global variable name\na = \$\#\n    \^~$/) do
-      eval('a = $#')
-    end
+    assert_syntax_error('a = $#', /as a global variable name\na = \$\#\n    \^~$/)
   end
 
   def test_invalid_instance_variable
     pattern = /without identifiers is not allowed as an instance variable name/
-    assert_raise_with_message(SyntaxError, pattern) { eval('@%') }
-    assert_raise_with_message(SyntaxError, pattern) { eval('@') }
+    assert_syntax_error('@%', pattern)
+    assert_syntax_error('@', pattern)
   end
 
   def test_invalid_class_variable
     pattern = /without identifiers is not allowed as a class variable name/
-    assert_raise_with_message(SyntaxError, pattern) { eval('@@%') }
-    assert_raise_with_message(SyntaxError, pattern) { eval('@@') }
+    assert_syntax_error('@@%', pattern)
+    assert_syntax_error('@@', pattern)
   end
 
   def test_invalid_char
@@ -788,56 +756,23 @@ x = __ENCODING__
   end
 
   def test_unassignable
-    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
+    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/)
   end
 
   def test_block_dup
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
-        foo(&proc{}) {}
-      END
-    end
+    assert_syntax_error("foo(&proc{}) {}", /both block arg and actual block/)
   end
 
   def test_set_backref
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
-        $& = 1
-      END
-    end
+    assert_syntax_error("$& = 1", /Can't set variable/)
   end
 
   def test_arg_concat
@@ -929,11 +864,7 @@ x = __ENCODING__
   end
 
   def test_no_blockarg
-    assert_raise(SyntaxError) do
-      eval <<-END, nil, __FILE__, __LINE__+1
-        yield(&:+)
-      END
-    end
+    assert_syntax_error("yield(&:+)", /block argument should not be given/)
   end
 
   def test_method_block_location
@@ -1105,38 +1036,26 @@ x = __ENCODING__
   end
 
   def test_unexpected_token_error
-    assert_raise(SyntaxError) do
-      eval('"x"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
-    end
+    assert_syntax_error('"x"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', /unexpected/)
   end
 
   def test_unexpected_token_after_numeric
-    assert_raise_with_message(SyntaxError, /^    \^~~\Z/) do
-      eval('0000xyz')
-    end
-    assert_raise_with_message(SyntaxError, /^    \^~~\Z/) do
-      eval('1.2i1.1')
-    end
-    assert_raise_with_message(SyntaxError, /^   \^~\Z/) do
-      eval('1.2.3')
-    end
+    assert_syntax_error('0000xyz', /^    \^~~\Z/)
+    assert_syntax_error('1.2i1.1', /^    \^~~\Z/)
+    assert_syntax_error('1.2.3', /^   \^~\Z/)
   end
 
   def test_truncated_source_line
-    e = assert_raise_with_message(SyntaxError, /unexpected local variable or method/) do
-      eval("'0123456789012345678901234567890123456789' abcdefghijklmnopqrstuvwxyz0123456789 0123456789012345678901234567890123456789")
-    end
+    e = assert_syntax_error("'0123456789012345678901234567890123456789' abcdefghijklmnopqrstuvwxyz0123456789 0123456789012345678901234567890123456789",
+                            /unexpected local variable or method/)
     line = e.message.lines[1]
     assert_operator(line, :start_with?, "...")
     assert_operator(line, :end_with?, "...\n")
   end
 
   def test_unterminated_regexp_error
-    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)
+    e = assert_syntax_error("/x", /unterminated regexp meets end of file/)
+    assert_not_match(/unexpected tSTRING_END/, e.message)
   end
 
   def test_lparenarg
@@ -1160,37 +1079,30 @@ x = __ENCODING__
     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_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") }
+    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_raise_with_message(SyntaxError, /^      \^~~\Z/) do
-      eval('class xxx end')
-    end
+    assert_syntax_error('class xxx end', /^      \^~~\Z/)
   end
 
   def test_whitespace_warning
-    assert_raise_with_message(SyntaxError, /backslash/) do
-      eval("\\foo")
-    end
-    assert_raise_with_message(SyntaxError, /escaped space/) do
-      eval("\\ ")
-    end
-    assert_raise_with_message(SyntaxError, /escaped horizontal tab/) do
-      eval("\\\t")
-    end
-    assert_raise_with_message(SyntaxError, /escaped form feed/) do
-      eval("\\\f")
-    end
-    assert_raise_with_message(SyntaxError, /escaped carriage return/) do
-      assert_warn(/middle of line/) {eval("\\\r")}
-    end
-    assert_raise_with_message(SyntaxError, /escaped vertical tab/) do
-      eval("\\\v")
-    end
+    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
diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index ef1e24221e..5fb4dfa64f 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -230,25 +230,11 @@ class TestSyntax < Test::Unit::TestCase
   end
 
   def test_keyword_self_reference
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var: defined?(var)) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var: var) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var: bar(var)) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var: bar {var}) var end")
-    end
+    message = /circular argument reference - var/
+    assert_syntax_error("def foo(var: defined?(var)) var end", message)
+    assert_syntax_error("def foo(var: var) var end", message)
+    assert_syntax_error("def foo(var: bar(var)) var end", message)
+    assert_syntax_error("def foo(var: bar {var}) var end", message)
 
     o = Object.new
     assert_warn("") do
@@ -269,25 +255,24 @@ class TestSyntax < Test::Unit::TestCase
   def test_keyword_invalid_name
     bug11663 = '[ruby-core:71356] [Bug #11663]'
 
-    o = o = Object.new
-    assert_syntax_error('def o.foo(arg1?:) end', /arg1\?/, bug11663)
-    assert_syntax_error('def o.foo(arg1?:, arg2:) end', /arg1\?/, bug11663)
+    assert_syntax_error('def foo(arg1?:) end', /arg1\?/, bug11663)
+    assert_syntax_error('def foo(arg1?:, arg2:) end', /arg1\?/, bug11663)
     assert_syntax_error('proc {|arg1?:|}', /arg1\?/, bug11663)
     assert_syntax_error('proc {|arg1?:, arg2:|}', /arg1\?/, bug11663)
 
     bug10545 = '[ruby-dev:48742] [Bug #10545]'
-    assert_syntax_error('def o.foo(FOO: a) end', /constant/, bug10545)
-    assert_syntax_error('def o.foo(@foo: a) end', /instance variable/)
-    assert_syntax_error('def o.foo(@@foo: a) end', /class variable/)
+    assert_syntax_error('def foo(FOO: a) end', /constant/, bug10545)
+    assert_syntax_error('def foo(@foo: a) end', /instance variable/)
+    assert_syntax_error('def foo(@@foo: a) end', /class variable/)
   end
 
   def test_keywords_specified_and_not_accepted
-    assert_syntax_error('def o.foo(a:, **nil) end', /unexpected/)
-    assert_syntax_error('def o.foo(a:, **nil, &b) end', /unexpected/)
-    assert_syntax_error('def o.foo(**a, **nil) end', /unexpected/)
-    assert_syntax_error('def o.foo(**a, **nil, &b) end', /unexpected/)
-    assert_syntax_error('def o.foo(**nil, **a) end', /unexpected/)
-    assert_syntax_error('def o.foo(**nil, **a, &b) end', /unexpected/)
+    assert_syntax_error('def foo(a:, **nil) end', /unexpected/)
+    assert_syntax_error('def foo(a:, **nil, &b) end', /unexpected/)
+    assert_syntax_error('def foo(**a, **nil) end', /unexpected/)
+    assert_syntax_error('def foo(**a, **nil, &b) end', /unexpected/)
+    assert_syntax_error('def foo(**nil, **a) end', /unexpected/)
+    assert_syntax_error('def foo(**nil, **a, &b) end', /unexpected/)
 
     assert_syntax_error('proc do |a:, **nil| end', /unexpected/)
     assert_syntax_error('proc do |a:, **nil, &b| end', /unexpected/)
@@ -298,35 +283,13 @@ class TestSyntax < Test::Unit::TestCase
   end
 
   def test_optional_self_reference
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var = defined?(var)) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var = var) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var = bar(var)) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var = bar {var}) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var = (def bar;end; var)) var end")
-    end
-
-    o = Object.new
-    assert_raise(SyntaxError) do
-      o.instance_eval("def foo(var = (def self.bar;end; var)) var end")
-    end
+    message = /circular argument reference - var/
+    assert_syntax_error("def foo(var = defined?(var)) var end", message)
+    assert_syntax_error("def foo(var = var) var end", message)
+    assert_syntax_error("def foo(var = bar(var)) var end", message)
+    assert_syntax_error("def foo(var = bar {var}) var end", message)
+    assert_syntax_error("def foo(var = (def bar;end; var)) var end", message)
+    assert_syntax_error("def foo(var = (def self.bar;end; var)) var end", message)
 
     o = Object.new
     assert_warn("") do
@@ -644,7 +607,7 @@ WARN
   def test_unassignable
     gvar = global_variables
     %w[self nil true false __FILE__ __LINE__ __ENCODING__].each do |kwd|
-      assert_raise(SyntaxError) {eval("#{kwd} = nil")}
+      assert_syntax_error("#{kwd} = nil", /Can't .* #{kwd}$/)
       assert_equal(gvar, global_variables)
     end
   end