* test: assert_raises has been deprecated since a long time ago.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19536 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

13 files changed, 55 insertions, 55 deletions

diff --git a/test/ruby/marshaltestlib.rb b/test/ruby/marshaltestlib.rb
index 0a70380d44..4486a78429 100644
--- a/test/ruby/marshaltestlib.rb
+++ b/test/ruby/marshaltestlib.rb
@@ -128,7 +128,7 @@ module MarshalTestLib
 
   def test_hash_default_proc
     h = Hash.new {}
-    assert_raises(TypeError) { marshaltest(h) }
+    assert_raise(TypeError) { marshaltest(h) }
   end
 
   def test_hash_ivar
@@ -418,16 +418,16 @@ module MarshalTestLib
   def test_singleton
     o = Object.new
     def o.m() end
-    assert_raises(TypeError) { marshaltest(o) }
+    assert_raise(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) }
+    assert_raise(TypeError) { marshaltest(o) }
+    assert_raise(TypeError) { marshaltest(c) }
+    assert_raise(TypeError) { marshaltest(ARGF) }
+    assert_raise(TypeError) { marshaltest(ENV) }
   end
 
   def test_extend
@@ -440,7 +440,7 @@ module MarshalTestLib
     marshal_equal(o) {|obj| class << obj; ancestors end}
     o = Object.new
     o.extend Module.new
-    assert_raises(TypeError) { marshaltest(o) }
+    assert_raise(TypeError) { marshaltest(o) }
   end
 
   def test_extend_string
@@ -453,16 +453,16 @@ module MarshalTestLib
     marshal_equal(o) {|obj| class << obj; ancestors end}
     o = ""
     o.extend Module.new
-    assert_raises(TypeError) { marshaltest(o) }
+    assert_raise(TypeError) { marshaltest(o) }
   end
 
   def test_anonymous
     c = Class.new
-    assert_raises(TypeError) { marshaltest(c) }
+    assert_raise(TypeError) { marshaltest(c) }
     o = c.new
-    assert_raises(TypeError) { marshaltest(o) }
+    assert_raise(TypeError) { marshaltest(o) }
     m = Module.new
-    assert_raises(TypeError) { marshaltest(m) }
+    assert_raise(TypeError) { marshaltest(m) }
   end
 
   def test_string_empty
diff --git a/test/ruby/test_beginendblock.rb b/test/ruby/test_beginendblock.rb
index 594596698b..463ebd94b6 100644
--- a/test/ruby/test_beginendblock.rb
+++ b/test/ruby/test_beginendblock.rb
@@ -32,11 +32,11 @@ class TestBeginEndBlock < Test::Unit::TestCase
   end
 
   def test_begininmethod
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       eval("def foo; BEGIN {}; end")
     end
 
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       eval('eval("def foo; BEGIN {}; end")')
     end
   end
diff --git a/test/ruby/test_call.rb b/test/ruby/test_call.rb
index da7ee93c73..8f861d96a1 100644
--- a/test/ruby/test_call.rb
+++ b/test/ruby/test_call.rb
@@ -8,8 +8,8 @@ class TestCall < Test::Unit::TestCase
   end
 
   def test_call
-    assert_raises(ArgumentError) {aaa()}
-    assert_raises(ArgumentError) {aaa}
+    assert_raise(ArgumentError) {aaa()}
+    assert_raise(ArgumentError) {aaa}
 
     assert_equal([1, 100], aaa(1))
     assert_equal([1, 2], aaa(1, 2))
diff --git a/test/ruby/test_clone.rb b/test/ruby/test_clone.rb
index 43c0cffa1d..c5e2469d10 100644
--- a/test/ruby/test_clone.rb
+++ b/test/ruby/test_clone.rb
@@ -21,7 +21,7 @@ class TestClone < Test::Unit::TestCase
     assert_equal("test", bar.test)
     assert_equal("test", foo.test)
 
-    assert_raises(NoMethodError) {foo.test2}
+    assert_raise(NoMethodError) {foo.test2}
 
     assert_equal([M003, M002, M001], M003.ancestors)
   end
diff --git a/test/ruby/test_env.rb b/test/ruby/test_env.rb
index 0ee702b222..f59fa14355 100644
--- a/test/ruby/test_env.rb
+++ b/test/ruby/test_env.rb
@@ -36,13 +36,13 @@ class TestEnv < Test::Unit::TestCase
       assert_equal('foo', ENV['test'])
     end
 
-    assert_raises(TypeError) {
+    assert_raise(TypeError) {
       tmp = ENV[1]
     }
-    assert_raises(TypeError) {
+    assert_raise(TypeError) {
       ENV[1] = 'foo'
     }
-    assert_raises(TypeError) {
+    assert_raise(TypeError) {
       ENV['test'] = 0
     }
   end
diff --git a/test/ruby/test_exception.rb b/test/ruby/test_exception.rb
index 3300fcdd74..cba88f5c90 100644
--- a/test/ruby/test_exception.rb
+++ b/test/ruby/test_exception.rb
@@ -24,7 +24,7 @@ class TestException < Test::Unit::TestCase
 
     # exception in rescue clause
     $string = "this must be handled no.3"
-    e = assert_raises(RuntimeError) do
+    e = assert_raise(RuntimeError) do
       begin
         raise "exception in rescue clause"
       rescue
@@ -36,7 +36,7 @@ class TestException < Test::Unit::TestCase
 
     # exception in ensure clause
     $string = "exception in ensure clause"
-    e = assert_raises(RuntimeError) do
+    e = assert_raise(RuntimeError) do
       begin
         raise "this must be handled no.4"
       ensure
diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb
index f6ac645321..ca6022a4fb 100644
--- a/test/ruby/test_iterator.rb
+++ b/test/ruby/test_iterator.rb
@@ -54,7 +54,7 @@ class TestIterator < Test::Unit::TestCase
     tt{|i| break if i == 5}
     assert_equal(0, i)
 
-    assert_raises(ArgumentError) do
+    assert_raise(ArgumentError) do
       tt3{}
     end
   end
@@ -64,7 +64,7 @@ class TestIterator < Test::Unit::TestCase
   end
 
   def test_block_argument_without_paren
-    assert_raises(ArgumentError) do
+    assert_raise(ArgumentError) do
       tt4{}
     end
   end
@@ -216,10 +216,10 @@ class TestIterator < Test::Unit::TestCase
 
   def test_argument
     assert_nothing_raised {lambda{||}.call}
-    assert_raises(ArgumentError) {lambda{||}.call(1)}
+    assert_raise(ArgumentError) {lambda{||}.call(1)}
     assert_nothing_raised {lambda{|a,|}.call(1)}
-    assert_raises(ArgumentError) {lambda{|a,|}.call()}
-    assert_raises(ArgumentError) {lambda{|a,|}.call(1,2)}
+    assert_raise(ArgumentError) {lambda{|a,|}.call()}
+    assert_raise(ArgumentError) {lambda{|a,|}.call(1,2)}
   end
 
   def get_block(&block)
@@ -235,9 +235,9 @@ class TestIterator < Test::Unit::TestCase
     assert_nothing_raised {get_block{|a,|}.call(1,2)}
 
     assert_nothing_raised {get_block(&lambda{||}).call()}
-    assert_raises(ArgumentError) {get_block(&lambda{||}).call(1)}
+    assert_raise(ArgumentError) {get_block(&lambda{||}).call(1)}
     assert_nothing_raised {get_block(&lambda{|a,|}).call(1)}
-    assert_raises(ArgumentError) {get_block(&lambda{|a,|}).call(1,2)}
+    assert_raise(ArgumentError) {get_block(&lambda{|a,|}).call(1,2)}
 
     block = get_block{11}
     assert_instance_of(Proc, block)
@@ -298,7 +298,7 @@ class TestIterator < Test::Unit::TestCase
   end
 
   def test_ljump
-    assert_raises(LocalJumpError) {get_block{break}.call}
+    assert_raise(LocalJumpError) {get_block{break}.call}
 
     # cannot use assert_nothing_raised due to passing block.
     begin
@@ -483,7 +483,7 @@ class TestIterator < Test::Unit::TestCase
     assert_equal(1, e.next)
     assert_equal(2, e.next)
     assert_equal(3, e.next)
-    assert_raises(StopIteration){e.next}
+    assert_raise(StopIteration){e.next}
     e.rewind
     assert_equal(1, e.next)
     e.rewind
diff --git a/test/ruby/test_lambda.rb b/test/ruby/test_lambda.rb
index bb0861ab53..241042d2c7 100644
--- a/test/ruby/test_lambda.rb
+++ b/test/ruby/test_lambda.rb
@@ -9,17 +9,17 @@ class TestLambdaParameters < Test::Unit::TestCase
   def test_call_simple
     assert_equal(1, lambda{|a| a}.call(1))
     assert_equal([1,2], lambda{|a, b| [a,b]}.call(1,2))
-    assert_raises(ArgumentError) { lambda{|a|}.call(1,2) }
-    assert_raises(ArgumentError) { lambda{|a|}.call() }
-    assert_raises(ArgumentError) { lambda{}.call(1) }
-    assert_raises(ArgumentError) { lambda{|a, b|}.call(1,2,3) }
+    assert_raise(ArgumentError) { lambda{|a|}.call(1,2) }
+    assert_raise(ArgumentError) { lambda{|a|}.call() }
+    assert_raise(ArgumentError) { lambda{}.call(1) }
+    assert_raise(ArgumentError) { lambda{|a, b|}.call(1,2,3) }
 
     assert_equal(1, ->(a){ a }.call(1))
     assert_equal([1,2], ->(a,b){ [a,b] }.call(1,2))
-    assert_raises(ArgumentError) { ->(a){ }.call(1,2) }
-    assert_raises(ArgumentError) { ->(a){ }.call() }
-    assert_raises(ArgumentError) { ->(){ }.call(1) }
-    assert_raises(ArgumentError) { ->(a,b){ }.call(1,2,3) }
+    assert_raise(ArgumentError) { ->(a){ }.call(1,2) }
+    assert_raise(ArgumentError) { ->(a){ }.call() }
+    assert_raise(ArgumentError) { ->(){ }.call(1) }
+    assert_raise(ArgumentError) { ->(a,b){ }.call(1,2,3) }
   end
 
 end
@@ -34,21 +34,21 @@ __END__
   def test_call_rest_args
     assert_equal([1,2], ->(*a){ a }.call(1,2))
     assert_equal([1,2,[]], ->(a,b,*c){ [a,b,c] }.call(1,2))
-    assert_raises(ArgumentError){ ->(a,*b){ }.call() }
+    assert_raise(ArgumentError){ ->(a,*b){ }.call() }
   end
 
   def test_call_opt_args
     assert_equal([1,2,3,4], ->(a,b,c=3,d=4){ [a,b,c,d] }.call(1,2))
     assert_equal([1,2,3,4], ->(a,b,c=0,d=4){ [a,b,c,d] }.call(1,2,3))
-    assert_raises(ArgumentError){ ->(a,b=1){ }.call() }
-    assert_raises(ArgumentError){ ->(a,b=1){ }.call(1,2,3) }
+    assert_raise(ArgumentError){ ->(a,b=1){ }.call() }
+    assert_raise(ArgumentError){ ->(a,b=1){ }.call(1,2,3) }
   end
 
   def test_call_rest_and_opt
     assert_equal([1,2,3,[]], ->(a,b=2,c=3,*d){ [a,b,c,d] }.call(1))
     assert_equal([1,2,3,[]], ->(a,b=0,c=3,*d){ [a,b,c,d] }.call(1,2))
     assert_equal([1,2,3,[4,5,6]], ->(a,b=0,c=0,*d){ [a,b,c,d] }.call(1,2,3,4,5,6))
-    assert_raises(ArgumentError){ ->(a,b=1,*c){ }.call() }
+    assert_raise(ArgumentError){ ->(a,b=1,*c){ }.call() }
   end
 
   def test_call_with_block
diff --git a/test/ruby/test_pack.rb b/test/ruby/test_pack.rb
index 30ffe13426..fee992efbc 100644
--- a/test/ruby/test_pack.rb
+++ b/test/ruby/test_pack.rb
@@ -47,15 +47,15 @@ class TestPack < Test::Unit::TestCase
   end
 
   def test_pack_U
-    assert_raises(RangeError) { [-0x40000001].pack("U") }
-    assert_raises(RangeError) { [-0x40000000].pack("U") }
-    assert_raises(RangeError) { [-1].pack("U") }
+    assert_raise(RangeError) { [-0x40000001].pack("U") }
+    assert_raise(RangeError) { [-0x40000000].pack("U") }
+    assert_raise(RangeError) { [-1].pack("U") }
     assert_equal "\000", [0].pack("U")
     assert_equal "\374\277\277\277\277\277", [0x3fffffff].pack("U")
     assert_equal "\375\200\200\200\200\200", [0x40000000].pack("U")
     assert_equal "\375\277\277\277\277\277", [0x7fffffff].pack("U")
-    assert_raises(RangeError) { [0x80000000].pack("U") }
-    assert_raises(RangeError) { [0x100000000].pack("U") }
+    assert_raise(RangeError) { [0x80000000].pack("U") }
+    assert_raise(RangeError) { [0x100000000].pack("U") }
   end
 
   def test_pack_P
diff --git a/test/ruby/test_readpartial.rb b/test/ruby/test_readpartial.rb
index c4f9d193f2..fd601e7d33 100644
--- a/test/ruby/test_readpartial.rb
+++ b/test/ruby/test_readpartial.rb
@@ -38,8 +38,8 @@ class TestReadPartial < Test::Unit::TestCase
       w.close
       assert_equal('ab', r.readpartial(2))
       assert_equal('c', r.readpartial(2))
-      assert_raises(EOFError) { r.readpartial(2) }
-      assert_raises(EOFError) { r.readpartial(2) }
+      assert_raise(EOFError) { r.readpartial(2) }
+      assert_raise(EOFError) { r.readpartial(2) }
     }
   end
 
@@ -48,7 +48,7 @@ class TestReadPartial < Test::Unit::TestCase
       w << 'abc'
       assert_equal('ab', r.readpartial(2))
       assert_equal('c', r.readpartial(2))
-      assert_raises(TimeoutError) {
+      assert_raise(TimeoutError) {
         timeout(0.1) { r.readpartial(2) }
       }
     }
@@ -62,7 +62,7 @@ class TestReadPartial < Test::Unit::TestCase
       assert_equal("de", r.readpartial(2))
       assert_equal("f\n", r.readpartial(4096))
       assert_equal("ghi\n", r.readpartial(4096))
-      assert_raises(TimeoutError) {
+      assert_raise(TimeoutError) {
         timeout(0.1) { r.readpartial(2) }
       }
     }
diff --git a/test/ruby/test_signal.rb b/test/ruby/test_signal.rb
index 0bc2078c18..7d9acfdc12 100644
--- a/test/ruby/test_signal.rb
+++ b/test/ruby/test_signal.rb
@@ -21,7 +21,7 @@ class TestSignal < Test::Unit::TestCase
       assert_equal 2, x
 
       Signal.trap(:INT) { raise "Interrupt" }
-      ex = assert_raises(RuntimeError) {
+      ex = assert_raise(RuntimeError) {
         Process.kill :INT, Process.pid
         sleep 0.1
       }
diff --git a/test/ruby/test_thread.rb b/test/ruby/test_thread.rb
index 4332b0fe2e..97e58cd9ea 100644
--- a/test/ruby/test_thread.rb
+++ b/test/ruby/test_thread.rb
@@ -71,7 +71,7 @@ class TestThread < Test::Unit::TestCase
     mutex = Mutex.new
     condvar = ConditionVariable.new
 
-    assert_raises(ThreadError) { condvar.wait(mutex) }
+    assert_raise(ThreadError) { condvar.wait(mutex) }
   end
 
   def test_condvar_wait_exception_handling
@@ -98,7 +98,7 @@ class TestThread < Test::Unit::TestCase
     end
 
     thread.raise Interrupt, "interrupt a dead condition variable"
-    assert_raises(Interrupt) { thread.value }
+    assert_raise(Interrupt) { thread.value }
     assert(locked)
   end
 
diff --git a/test/ruby/test_variable.rb b/test/ruby/test_variable.rb
index 53cd151585..5a0c7800bb 100644
--- a/test/ruby/test_variable.rb
+++ b/test/ruby/test_variable.rb
@@ -37,7 +37,7 @@ class TestVariable < Test::Unit::TestCase
     assert_instance_of(Fixnum, $$)
     
     # read-only variable
-    assert_raises(NameError) do
+    assert_raise(NameError) do
       $$ = 5
     end