summaryrefslogtreecommitdiff
path: root/test/json/test_json.rb
diff options
context:
space:
mode:
authornaruse <naruse@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2009-09-01 17:34:50 +0000
committernaruse <naruse@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2009-09-01 17:34:50 +0000
commitd99ac4f829dd0903f20e02de5dbba0ddc175c1f3 (patch)
tree18f7c54ef29c879c9a3c342bcea594bde36ca2b5 /test/json/test_json.rb
parent596b68cc6b6333a3939ebca3ae09fecc491e5718 (diff)
Add tests of JSON 1.1.9.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@24729 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'test/json/test_json.rb')
-rwxr-xr-xtest/json/test_json.rb132
1 files changed, 80 insertions, 52 deletions
diff --git a/test/json/test_json.rb b/test/json/test_json.rb
index ae77f7b..5307609 100755
--- a/test/json/test_json.rb
+++ b/test/json/test_json.rb
@@ -2,7 +2,11 @@
# -*- coding: utf-8 -*-
require 'test/unit'
-require 'json'
+case ENV['JSON']
+when 'pure' then require 'json/pure'
+when 'ext' then require 'json/ext'
+else require 'json'
+end
require 'stringio'
class TC_JSON < Test::Unit::TestCase
@@ -26,7 +30,7 @@ class TC_JSON < Test::Unit::TestCase
'h' => 1000.0,
'i' => 0.001
}
- @json = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
+ @json = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
'"g":"\\"\\u0000\\u001f","h":1.0E3,"i":1.0E-3}'
end
@@ -49,10 +53,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_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_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_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 +65,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_raise(ParserError) { parse('[NaN]') }
+ assert_raises(ParserError) { parse('[NaN]') }
assert parse('[NaN]', :allow_nan => true).first.nan?
- assert_raise(ParserError) { parse('[Infinity]') }
+ assert_raises(ParserError) { parse('[Infinity]') }
assert_equal [1.0/0], parse('[Infinity]', :allow_nan => true)
- assert_raise(ParserError) { parse('[-Infinity]') }
+ assert_raises(ParserError) { parse('[-Infinity]') }
assert_equal [-1.0/0], parse('[-Infinity]', :allow_nan => true)
assert_equal([""], parse('[""]'))
assert_equal(["foobar"], parse('["foobar"]'))
@@ -79,7 +83,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_raise(JSON::ParserError) { parse('{false}') }
+ assert_raises(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 } '))
@@ -90,22 +94,30 @@ class TC_JSON < Test::Unit::TestCase
assert_equal({ "a" => 0.23 }, parse(' { "a" : 0.23 } '))
end
- def test_parse_more_complex_arrays
- a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
- a.permutation do |orig_ary|
- json = pretty_generate(orig_ary)
- assert_equal orig_ary, parse(json)
+ begin
+ require 'permutation'
+ def test_parse_more_complex_arrays
+ a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
+ perms = Permutation.for a
+ perms.each do |perm|
+ orig_ary = perm.project
+ json = pretty_generate(orig_ary)
+ assert_equal orig_ary, parse(json)
+ end
end
- end
- def test_parse_complex_objects
- a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
- a.permutation do |orig_ary|
- s = "a"
- orig_obj = orig_ary.inject({}) { |h, x| h[s.dup] = x; s = s.succ; h }
- json = pretty_generate(orig_obj)
- assert_equal orig_obj, parse(json)
+ def test_parse_complex_objects
+ a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
+ perms = Permutation.for a
+ perms.each do |perm|
+ s = "a"
+ orig_obj = perm.project.inject({}) { |h, x| h[s.dup] = x; s = s.succ; h }
+ json = pretty_generate(orig_obj)
+ assert_equal orig_obj, parse(json)
+ end
end
+ rescue LoadError
+ warn "Skipping permutation tests."
end
def test_parse_arrays
@@ -134,10 +146,18 @@ class TC_JSON < Test::Unit::TestCase
assert_equal(@ary,
parse('[[1],["foo"],[3.14],[47.11e+2],[2718.0E-3],[null],[[1,-2,3]]'\
',[false],[true]]'))
- assert_equal(@ary, parse(%Q{ [ [1] , ["foo"] , [3.14] \t , [47.11e+2]
+ assert_equal(@ary, parse(%Q{ [ [1] , ["foo"] , [3.14] \t , [47.11e+2]
, [2718.0E-3 ],\r[ null] , [[1, -2, 3 ]], [false ],[ true]\n ] }))
end
+ class SubArray < Array; end
+
+ def test_parse_array_custom_class
+ res = parse('[]', :array_class => SubArray)
+ assert_equal([], res)
+ assert_equal(SubArray, res.class)
+ end
+
def test_parse_object
assert_equal({}, parse('{}'))
assert_equal({}, parse(' { } '))
@@ -145,6 +165,14 @@ class TC_JSON < Test::Unit::TestCase
assert_equal({'foo'=>'bar'}, parse(' { "foo" : "bar" } '))
end
+ class SubHash < Hash; end
+
+ def test_parse_object_custom_class
+ res = parse('{}', :object_class => SubHash)
+ assert_equal({}, res)
+ assert_equal(SubHash, res.class)
+ end
+
def test_parser_reset
parser = Parser.new(@json)
assert_equal(@hash, parser.parse)
@@ -173,7 +201,7 @@ EOT
* comment */
}
EOT
- assert_raise(ParserError) { parse(json) }
+ assert_raises(ParserError) { parse(json) }
json = <<EOT
{
"key1":"value1" /* multi line
@@ -182,7 +210,7 @@ EOT
and again, throw an Error */
}
EOT
- assert_raise(ParserError) { parse(json) }
+ assert_raises(ParserError) { parse(json) }
json = <<EOT
{
"key1":"value1" /*/*/
@@ -202,7 +230,7 @@ EOT
assert_equal json, JSON.unparse(data)
assert_equal data, JSON.parse(json)
#
- json = '["\/"]'
+ json = '["/"]'
data = JSON.parse(json)
assert_equal ['/'], data
assert_equal json, JSON.unparse(data)
@@ -218,32 +246,32 @@ EOT
end
def test_wrong_inputs
- 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(' ') }
+ 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(' ') }
end
def test_nesting
- assert_raise(JSON::NestingError) { JSON.parse '[[]]', :max_nesting => 1 }
- assert_raise(JSON::NestingError) { JSON.parser.new('[[]]', :max_nesting => 1).parse }
+ assert_raises(JSON::NestingError) { JSON.parse '[[]]', :max_nesting => 1 }
+ assert_raises(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_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 }
+ 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 }
ok = JSON.parse too_deep, :max_nesting => 20
assert_equal too_deep_ary, ok
ok = JSON.parse too_deep, :max_nesting => nil
@@ -252,10 +280,10 @@ EOT
assert_equal too_deep_ary, ok
ok = JSON.parse too_deep, :max_nesting => 0
assert_equal too_deep_ary, ok
- assert_raise(JSON::NestingError) { JSON.generate [[]], :max_nesting => 1 }
+ assert_raises(JSON::NestingError) { JSON.generate [[]], :max_nesting => 1 }
assert_equal '[[]]', JSON.generate([[]], :max_nesting => 2)
- assert_raise(JSON::NestingError) { JSON.generate too_deep_ary }
- assert_raise(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 19 }
+ assert_raises(JSON::NestingError) { JSON.generate too_deep_ary }
+ assert_raises(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
@@ -270,8 +298,8 @@ EOT
too_deep = '[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]'
assert_equal too_deep, JSON.dump(eval(too_deep))
assert_kind_of String, Marshal.dump(eval(too_deep))
- assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 19) }
- assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 19) }
+ assert_raises(ArgumentError) { JSON.dump(eval(too_deep), 19) }
+ assert_raises(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