aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--test/fiddle/test_closure.rb6
-rw-r--r--test/fiddle/test_cparser.rb4
-rw-r--r--test/fiddle/test_func.rb2
-rw-r--r--test/fiddle/test_function.rb10
-rw-r--r--test/fiddle/test_handle.rb18
-rw-r--r--test/fiddle/test_import.rb2
-rw-r--r--test/fiddle/test_pointer.rb2
-rwxr-xr-xtest/json/test_json.rb70
-rw-r--r--test/json/test_json_addition.rb4
-rw-r--r--test/json/test_json_encoding.rb2
-rw-r--r--test/json/test_json_fixtures.rb2
-rw-r--r--test/json/test_json_generate.rb30
-rw-r--r--test/lib/test/unit/assertions.rb4
-rw-r--r--test/ruby/test_hash.rb2
14 files changed, 81 insertions, 77 deletions
diff --git a/test/fiddle/test_closure.rb b/test/fiddle/test_closure.rb
index 56839e7b63..e9dcecef67 100644
--- a/test/fiddle/test_closure.rb
+++ b/test/fiddle/test_closure.rb
@@ -6,15 +6,15 @@ end
module Fiddle
class TestClosure < Fiddle::TestCase
def test_argument_errors
- assert_raises(TypeError) do
+ assert_raise(TypeError) do
Closure.new(TYPE_INT, TYPE_INT)
end
- assert_raises(TypeError) do
+ assert_raise(TypeError) do
Closure.new('foo', [TYPE_INT])
end
- assert_raises(TypeError) do
+ assert_raise(TypeError) do
Closure.new(TYPE_INT, ['meow!'])
end
end
diff --git a/test/fiddle/test_cparser.rb b/test/fiddle/test_cparser.rb
index 4d4799d8d6..2810e393b2 100644
--- a/test/fiddle/test_cparser.rb
+++ b/test/fiddle/test_cparser.rb
@@ -60,7 +60,7 @@ module Fiddle
end
def test_undefined_ctype
- assert_raises(DLError) { parse_ctype('DWORD') }
+ assert_raise(DLError) { parse_ctype('DWORD') }
end
def test_undefined_ctype_with_type_alias
@@ -92,7 +92,7 @@ module Fiddle
end
def test_struct_undefined
- assert_raises(DLError) { parse_struct_signature(['int i', 'DWORD cb']) }
+ assert_raise(DLError) { parse_struct_signature(['int i', 'DWORD cb']) }
end
def test_struct_undefined_with_type_alias
diff --git a/test/fiddle/test_func.rb b/test/fiddle/test_func.rb
index 529aaa8baf..01ac09b52c 100644
--- a/test/fiddle/test_func.rb
+++ b/test/fiddle/test_func.rb
@@ -12,7 +12,7 @@ module Fiddle
def test_syscall_with_tainted_string
f = Function.new(@libc['system'], [TYPE_VOIDP], TYPE_INT)
- assert_raises(SecurityError) do
+ assert_raise(SecurityError) do
Thread.new {
$SAFE = 1
f.call("uname -rs".taint)
diff --git a/test/fiddle/test_function.rb b/test/fiddle/test_function.rb
index de7c9585f7..2e3a432ec3 100644
--- a/test/fiddle/test_function.rb
+++ b/test/fiddle/test_function.rb
@@ -23,15 +23,15 @@ module Fiddle
end
def test_argument_errors
- assert_raises(TypeError) do
+ assert_raise(TypeError) do
Function.new(@libm['sin'], TYPE_DOUBLE, TYPE_DOUBLE)
end
- assert_raises(TypeError) do
+ assert_raise(TypeError) do
Function.new(@libm['sin'], ['foo'], TYPE_DOUBLE)
end
- assert_raises(TypeError) do
+ assert_raise(TypeError) do
Function.new(@libm['sin'], [TYPE_DOUBLE], 'foo')
end
end
@@ -49,10 +49,10 @@ module Fiddle
}.new(TYPE_INT, [TYPE_INT])
func = Function.new(closure, [TYPE_INT], TYPE_INT)
- assert_raises(ArgumentError) do
+ assert_raise(ArgumentError) do
func.call(1,2,3)
end
- assert_raises(ArgumentError) do
+ assert_raise(ArgumentError) do
func.call
end
end
diff --git a/test/fiddle/test_handle.rb b/test/fiddle/test_handle.rb
index 2480230829..54165f00af 100644
--- a/test/fiddle/test_handle.rb
+++ b/test/fiddle/test_handle.rb
@@ -15,8 +15,8 @@ module Fiddle
end
def test_static_sym_unknown
- assert_raises(DLError) { Fiddle::Handle.sym('fooo') }
- assert_raises(DLError) { Fiddle::Handle['fooo'] }
+ assert_raise(DLError) { Fiddle::Handle.sym('fooo') }
+ assert_raise(DLError) { Fiddle::Handle['fooo'] }
end
def test_static_sym
@@ -41,20 +41,20 @@ module Fiddle
def test_sym_closed_handle
handle = Fiddle::Handle.new(LIBC_SO)
handle.close
- assert_raises(DLError) { handle.sym("calloc") }
- assert_raises(DLError) { handle["calloc"] }
+ assert_raise(DLError) { handle.sym("calloc") }
+ assert_raise(DLError) { handle["calloc"] }
end
def test_sym_unknown
handle = Fiddle::Handle.new(LIBC_SO)
- assert_raises(DLError) { handle.sym('fooo') }
- assert_raises(DLError) { handle['fooo'] }
+ assert_raise(DLError) { handle.sym('fooo') }
+ assert_raise(DLError) { handle['fooo'] }
end
def test_sym_with_bad_args
handle = Handle.new(LIBC_SO)
- assert_raises(TypeError) { handle.sym(nil) }
- assert_raises(TypeError) { handle[nil] }
+ assert_raise(TypeError) { handle.sym(nil) }
+ assert_raise(TypeError) { handle[nil] }
end
def test_sym
@@ -71,7 +71,7 @@ module Fiddle
def test_handle_close_twice
handle = Handle.new(LIBC_SO)
handle.close
- assert_raises(DLError) do
+ assert_raise(DLError) do
handle.close
end
end
diff --git a/test/fiddle/test_import.rb b/test/fiddle/test_import.rb
index c83f50fe44..f94d67b459 100644
--- a/test/fiddle/test_import.rb
+++ b/test/fiddle/test_import.rb
@@ -44,7 +44,7 @@ module Fiddle
class TestImport < TestCase
def test_ensure_call_dlload
- err = assert_raises(RuntimeError) do
+ err = assert_raise(RuntimeError) do
Class.new do
extend Importer
extern "void *strcpy(char*, char*)"
diff --git a/test/fiddle/test_pointer.rb b/test/fiddle/test_pointer.rb
index 3ea9bc86dd..ef54470943 100644
--- a/test/fiddle/test_pointer.rb
+++ b/test/fiddle/test_pointer.rb
@@ -105,7 +105,7 @@ module Fiddle
ptr2 = Pointer.to_ptr Struct.new(:to_ptr).new(ptr)
assert_equal ptr, ptr2
- assert_raises(Fiddle::DLError) do
+ assert_raise(Fiddle::DLError) do
Pointer.to_ptr Struct.new(:to_ptr).new(nil)
end
end
diff --git a/test/json/test_json.rb b/test/json/test_json.rb
index 96ba744478..07287eed81 100755
--- a/test/json/test_json.rb
+++ b/test/json/test_json.rb
@@ -65,10 +65,10 @@ class TestJSON < Test::Unit::TestCase
assert_equal([23], parse('[23]'))
assert_equal([0.23], parse('[0.23]'))
assert_equal([0.0], parse('[0e0]'))
- assert_raises(JSON::ParserError) { parse('[+23.2]') }
- assert_raises(JSON::ParserError) { parse('[+23]') }
- assert_raises(JSON::ParserError) { parse('[.23]') }
- assert_raises(JSON::ParserError) { parse('[023]') }
+ assert_raise(JSON::ParserError) { parse('[+23.2]') }
+ assert_raise(JSON::ParserError) { parse('[+23]') }
+ assert_raise(JSON::ParserError) { parse('[.23]') }
+ assert_raise(JSON::ParserError) { parse('[023]') }
assert_equal_float [3.141], parse('[3.141]')
assert_equal_float [-3.141], parse('[-3.141]')
assert_equal_float [3.141], parse('[3141e-3]')
@@ -77,11 +77,11 @@ class TestJSON < Test::Unit::TestCase
assert_equal_float [3.141], parse('[3141.0E-3]')
assert_equal_float [-3.141], parse('[-3141.0e-3]')
assert_equal_float [-3.141], parse('[-3141e-3]')
- assert_raises(ParserError) { parse('[NaN]') }
+ assert_raise(ParserError) { parse('[NaN]') }
assert parse('[NaN]', :allow_nan => true).first.nan?
- assert_raises(ParserError) { parse('[Infinity]') }
+ assert_raise(ParserError) { parse('[Infinity]') }
assert_equal [1.0/0], parse('[Infinity]', :allow_nan => true)
- assert_raises(ParserError) { parse('[-Infinity]') }
+ assert_raise(ParserError) { parse('[-Infinity]') }
assert_equal [-1.0/0], parse('[-Infinity]', :allow_nan => true)
assert_equal([""], parse('[""]'))
assert_equal(["foobar"], parse('["foobar"]'))
@@ -95,7 +95,7 @@ class TestJSON < Test::Unit::TestCase
assert_equal({ "a" => nil }, parse('{"a":null}'))
assert_equal({ "a" => false }, parse('{ "a" : false } '))
assert_equal({ "a" => false }, parse('{"a":false}'))
- assert_raises(JSON::ParserError) { parse('{false}') }
+ assert_raise(JSON::ParserError) { parse('{false}') }
assert_equal({ "a" => true }, parse('{"a":true}'))
assert_equal({ "a" => true }, parse(' { "a" : true } '))
assert_equal({ "a" => -23 }, parse(' { "a" : -23 } '))
@@ -380,7 +380,7 @@ EOT
* comment */
}
EOT
- assert_raises(ParserError) { parse(json) }
+ assert_raise(ParserError) { parse(json) }
json = <<EOT
{
"key1":"value1" /* multi line
@@ -389,7 +389,7 @@ EOT
and again, throw an Error */
}
EOT
- assert_raises(ParserError) { parse(json) }
+ assert_raise(ParserError) { parse(json) }
json = <<EOT
{
"key1":"value1" /*/*/
@@ -425,32 +425,32 @@ EOT
end
def test_wrong_inputs
- assert_raises(ParserError) { JSON.parse('"foo"') }
- assert_raises(ParserError) { JSON.parse('123') }
- assert_raises(ParserError) { JSON.parse('[] bla') }
- assert_raises(ParserError) { JSON.parse('[] 1') }
- assert_raises(ParserError) { JSON.parse('[] []') }
- assert_raises(ParserError) { JSON.parse('[] {}') }
- assert_raises(ParserError) { JSON.parse('{} []') }
- assert_raises(ParserError) { JSON.parse('{} {}') }
- assert_raises(ParserError) { JSON.parse('[NULL]') }
- assert_raises(ParserError) { JSON.parse('[FALSE]') }
- assert_raises(ParserError) { JSON.parse('[TRUE]') }
- assert_raises(ParserError) { JSON.parse('[07] ') }
- assert_raises(ParserError) { JSON.parse('[0a]') }
- assert_raises(ParserError) { JSON.parse('[1.]') }
- assert_raises(ParserError) { JSON.parse(' ') }
+ assert_raise(ParserError) { JSON.parse('"foo"') }
+ assert_raise(ParserError) { JSON.parse('123') }
+ assert_raise(ParserError) { JSON.parse('[] bla') }
+ assert_raise(ParserError) { JSON.parse('[] 1') }
+ assert_raise(ParserError) { JSON.parse('[] []') }
+ assert_raise(ParserError) { JSON.parse('[] {}') }
+ assert_raise(ParserError) { JSON.parse('{} []') }
+ assert_raise(ParserError) { JSON.parse('{} {}') }
+ assert_raise(ParserError) { JSON.parse('[NULL]') }
+ assert_raise(ParserError) { JSON.parse('[FALSE]') }
+ assert_raise(ParserError) { JSON.parse('[TRUE]') }
+ assert_raise(ParserError) { JSON.parse('[07] ') }
+ assert_raise(ParserError) { JSON.parse('[0a]') }
+ assert_raise(ParserError) { JSON.parse('[1.]') }
+ assert_raise(ParserError) { JSON.parse(' ') }
end
def test_nesting
- assert_raises(JSON::NestingError) { JSON.parse '[[]]', :max_nesting => 1 }
- assert_raises(JSON::NestingError) { JSON.parser.new('[[]]', :max_nesting => 1).parse }
+ assert_raise(JSON::NestingError) { JSON.parse '[[]]', :max_nesting => 1 }
+ assert_raise(JSON::NestingError) { JSON.parser.new('[[]]', :max_nesting => 1).parse }
assert_equal [[]], JSON.parse('[[]]', :max_nesting => 2)
too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
too_deep_ary = eval too_deep
- assert_raises(JSON::NestingError) { JSON.parse too_deep }
- assert_raises(JSON::NestingError) { JSON.parser.new(too_deep).parse }
- assert_raises(JSON::NestingError) { JSON.parse too_deep, :max_nesting => 100 }
+ assert_raise(JSON::NestingError) { JSON.parse too_deep }
+ assert_raise(JSON::NestingError) { JSON.parser.new(too_deep).parse }
+ assert_raise(JSON::NestingError) { JSON.parse too_deep, :max_nesting => 100 }
ok = JSON.parse too_deep, :max_nesting => 101
assert_equal too_deep_ary, ok
ok = JSON.parse too_deep, :max_nesting => nil
@@ -459,10 +459,10 @@ EOT
assert_equal too_deep_ary, ok
ok = JSON.parse too_deep, :max_nesting => 0
assert_equal too_deep_ary, ok
- assert_raises(JSON::NestingError) { JSON.generate [[]], :max_nesting => 1 }
+ assert_raise(JSON::NestingError) { JSON.generate [[]], :max_nesting => 1 }
assert_equal '[[]]', JSON.generate([[]], :max_nesting => 2)
- assert_raises(JSON::NestingError) { JSON.generate too_deep_ary }
- assert_raises(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 100 }
+ assert_raise(JSON::NestingError) { JSON.generate too_deep_ary }
+ assert_raise(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 100 }
ok = JSON.generate too_deep_ary, :max_nesting => 101
assert_equal too_deep, ok
ok = JSON.generate too_deep_ary, :max_nesting => nil
@@ -505,8 +505,8 @@ EOT
too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
assert_equal too_deep, JSON.dump(eval(too_deep))
assert_kind_of String, Marshal.dump(eval(too_deep))
- assert_raises(ArgumentError) { JSON.dump(eval(too_deep), 100) }
- assert_raises(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+ assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 100) }
+ assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
assert_equal too_deep, JSON.dump(eval(too_deep), 101)
assert_kind_of String, Marshal.dump(eval(too_deep), 101)
output = StringIO.new
diff --git a/test/json/test_json_addition.rb b/test/json/test_json_addition.rb
index a30f06addd..6034a183bd 100644
--- a/test/json/test_json_addition.rb
+++ b/test/json/test_json_addition.rb
@@ -112,7 +112,7 @@ class TestJSONAddition < Test::Unit::TestCase
c = C.new
assert !C.json_creatable?
json = generate(c)
- assert_raises(ArgumentError, NameError) { JSON.parse(json, :create_additions => true) }
+ assert_raise(ArgumentError, NameError) { JSON.parse(json, :create_additions => true) }
end
def test_raw_strings
@@ -151,7 +151,7 @@ class TestJSONAddition < Test::Unit::TestCase
assert_equal s, JSON(JSON(s), :create_additions => true)
struct = Struct.new :foo, :bar
s = struct.new 4711, 'foot'
- assert_raises(JSONError) { JSON(s) }
+ assert_raise(JSONError) { JSON(s) }
begin
raise TypeError, "test me"
rescue TypeError => e
diff --git a/test/json/test_json_encoding.rb b/test/json/test_json_encoding.rb
index fa7d878920..13903cd266 100644
--- a/test/json/test_json_encoding.rb
+++ b/test/json/test_json_encoding.rb
@@ -59,7 +59,7 @@ class TestJSONEncoding < Test::Unit::TestCase
assert_equal @generated, JSON.generate(@utf_16_data, :ascii_only => true)
else
# XXX checking of correct utf8 data is not as strict (yet?) without :ascii_only
- assert_raises(JSON::GeneratorError) { JSON.generate(@utf_16_data, :ascii_only => true) }
+ assert_raise(JSON::GeneratorError) { JSON.generate(@utf_16_data, :ascii_only => true) }
end
end
end
diff --git a/test/json/test_json_fixtures.rb b/test/json/test_json_fixtures.rb
index 584dffdfdb..c861439573 100644
--- a/test/json/test_json_fixtures.rb
+++ b/test/json/test_json_fixtures.rb
@@ -26,7 +26,7 @@ class TestJSONFixtures < Test::Unit::TestCase
def test_failing
for name, source in @failed
- assert_raises(JSON::ParserError, JSON::NestingError,
+ assert_raise(JSON::ParserError, JSON::NestingError,
"Did not fail for fixture '#{name}': #{source.inspect}") do
JSON.parse(source)
end
diff --git a/test/json/test_json_generate.rb b/test/json/test_json_generate.rb
index ce470db3c2..5da0d2f4f0 100644
--- a/test/json/test_json_generate.rb
+++ b/test/json/test_json_generate.rb
@@ -123,12 +123,12 @@ EOT
assert s[:check_circular?]
h = { 1=>2 }
h[3] = h
- assert_raises(JSON::NestingError) { generate(h) }
- assert_raises(JSON::NestingError) { generate(h, s) }
+ assert_raise(JSON::NestingError) { generate(h) }
+ assert_raise(JSON::NestingError) { generate(h, s) }
s = JSON.state.new
a = [ 1, 2 ]
a << a
- assert_raises(JSON::NestingError) { generate(a, s) }
+ assert_raise(JSON::NestingError) { generate(a, s) }
assert s.check_circular?
assert s[:check_circular?]
end
@@ -185,34 +185,34 @@ EOT
end
def test_allow_nan
- assert_raises(GeneratorError) { generate([JSON::NaN]) }
+ assert_raise(GeneratorError) { generate([JSON::NaN]) }
assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
- assert_raises(GeneratorError) { fast_generate([JSON::NaN]) }
- assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) }
+ assert_raise(GeneratorError) { fast_generate([JSON::NaN]) }
+ assert_raise(GeneratorError) { pretty_generate([JSON::NaN]) }
assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
- assert_raises(GeneratorError) { generate([JSON::Infinity]) }
+ assert_raise(GeneratorError) { generate([JSON::Infinity]) }
assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
- assert_raises(GeneratorError) { fast_generate([JSON::Infinity]) }
- assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) }
+ assert_raise(GeneratorError) { fast_generate([JSON::Infinity]) }
+ assert_raise(GeneratorError) { pretty_generate([JSON::Infinity]) }
assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
- assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) }
+ assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) }
assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
- assert_raises(GeneratorError) { fast_generate([JSON::MinusInfinity]) }
- assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
+ assert_raise(GeneratorError) { fast_generate([JSON::MinusInfinity]) }
+ assert_raise(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
end
def test_depth
ary = []; ary << ary
assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
- assert_raises(JSON::NestingError) { JSON.generate(ary) }
+ assert_raise(JSON::NestingError) { JSON.generate(ary) }
assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
- assert_raises(JSON::NestingError) { JSON.pretty_generate(ary) }
+ assert_raise(JSON::NestingError) { JSON.pretty_generate(ary) }
assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
s = JSON.state.new
assert_equal 0, s.depth
- assert_raises(JSON::NestingError) { ary.to_json(s) }
+ assert_raise(JSON::NestingError) { ary.to_json(s) }
assert_equal 100, s.depth
end
diff --git a/test/lib/test/unit/assertions.rb b/test/lib/test/unit/assertions.rb
index a317a850fd..ca15bef720 100644
--- a/test/lib/test/unit/assertions.rb
+++ b/test/lib/test/unit/assertions.rb
@@ -95,6 +95,10 @@ module Test
flunk(message(msg) {"#{mu_pp(exp)} expected but nothing was raised"})
end
+ def assert_raises(*exp, &b)
+ raise NoMethodError, "use assert_raise", caller
+ end
+
# :call-seq:
# assert_raise_with_message(exception, expected, msg = nil, &block)
#
diff --git a/test/ruby/test_hash.rb b/test/ruby/test_hash.rb
index e8d3d21484..e8f0f87326 100644
--- a/test/ruby/test_hash.rb
+++ b/test/ruby/test_hash.rb
@@ -506,7 +506,7 @@ class TestHash < Test::Unit::TestCase
assert_equal(4, res.length)
assert_equal %w( three two one nil ), res
- assert_raises KeyError do
+ assert_raise KeyError do
@h.fetch_values(3, 'invalid')
end
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 06:05:23 +0000