diff options
Diffstat (limited to 'test/json/test_json.rb')
| -rwxr-xr-x | test/json/test_json.rb | 132 |
1 files changed, 80 insertions, 52 deletions
diff --git a/test/json/test_json.rb b/test/json/test_json.rb index ae77f7b14f..53076095f7 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 |