summaryrefslogtreecommitdiff
path: root/test/json/test_json.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/json/test_json.rb')
-rwxr-xr-xtest/json/test_json.rb70
1 files changed, 35 insertions, 35 deletions
diff --git a/test/json/test_json.rb b/test/json/test_json.rb
index 2c706d52f1..8cb226702b 100755
--- a/test/json/test_json.rb
+++ b/test/json/test_json.rb
@@ -49,10 +49,10 @@ class TC_JSON < 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]')
@@ -61,11 +61,11 @@ class TC_JSON < 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"]'))
@@ -79,7 +79,7 @@ class TC_JSON < 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 } '))
@@ -181,7 +181,7 @@ EOT
* comment */
}
EOT
- assert_raises(ParserError) { parse(json) }
+ assert_raise(ParserError) { parse(json) }
json = <<EOT
{
"key1":"value1" /* multi line
@@ -190,7 +190,7 @@ EOT
and again, throw an Error */
}
EOT
- assert_raises(ParserError) { parse(json) }
+ assert_raise(ParserError) { parse(json) }
json = <<EOT
{
"key1":"value1" /*/*/
@@ -226,32 +226,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 => 19 }
+ 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 => 19 }
ok = JSON.parse too_deep, :max_nesting => 20
assert_equal too_deep_ary, ok
ok = JSON.parse too_deep, :max_nesting => nil
@@ -260,10 +260,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 => 19 }
+ assert_raise(JSON::NestingError) { JSON.generate too_deep_ary }
+ assert_raise(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 19 }
ok = JSON.generate too_deep_ary, :max_nesting => 20
assert_equal too_deep, ok
ok = JSON.generate too_deep_ary, :max_nesting => nil
@@ -278,8 +278,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), 19) }
- assert_raises(ArgumentError) { Marshal.dump(eval(too_deep), 19) }
+ assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 19) }
+ assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 19) }
assert_equal too_deep, JSON.dump(eval(too_deep), 20)
assert_kind_of String, Marshal.dump(eval(too_deep), 20)
output = StringIO.new