From 54592ad6276a17d95f2186c8631197ddb172020b Mon Sep 17 00:00:00 2001 From: naruse Date: Mon, 26 Apr 2010 00:06:35 +0000 Subject: * ext/json: Update to JSON 1.4.1. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27493 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- test/json/test_json.rb | 73 ++++++++++++++++++++++++++++++----------- test/json/test_json_addition.rb | 10 +++--- test/json/test_json_encoding.rb | 68 ++++++++++++++++++++++++++++++++++++++ test/json/test_json_generate.rb | 44 +++++++++++++++++-------- test/json/test_json_rails.rb | 12 +++---- test/json/test_json_unicode.rb | 26 +++++++++++---- 6 files changed, 181 insertions(+), 52 deletions(-) create mode 100644 test/json/test_json_encoding.rb mode change 100644 => 100755 test/json/test_json_generate.rb mode change 100644 => 100755 test/json/test_json_rails.rb (limited to 'test/json') diff --git a/test/json/test_json.rb b/test/json/test_json.rb index ce90d6e62b..f5a432f8bd 100755 --- a/test/json/test_json.rb +++ b/test/json/test_json.rb @@ -9,6 +9,20 @@ else require 'json' end require 'stringio' +unless Array.method_defined?(:permutation) + begin + require 'enumerator' + require 'permutation' + class Array + def permutation + Permutation.for(self).to_enum.map { |x| x.project } + end + end + rescue LoadError + warn "Skipping permutation tests." + end +end + class TC_JSON < Test::Unit::TestCase include JSON @@ -94,22 +108,23 @@ 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.each do |perm| - orig_ary = a - json = pretty_generate(orig_ary) - assert_equal orig_ary, parse(json) + if Array.method_defined?(:permutation) + def test_parse_more_complex_arrays + a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }] + a.permutation.each do |perm| + json = pretty_generate(perm) + assert_equal perm, 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.each do |perm| - s = "a" - orig_obj = a.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" => {} }] + a.permutation.each do |perm| + s = "a" + orig_obj = perm.inject({}) { |h, x| h[s.dup] = x; s = s.succ; h } + json = pretty_generate(orig_obj) + assert_equal orig_obj, parse(json) + end end end @@ -215,27 +230,27 @@ EOT def test_backslash data = [ '\\.(?i:gif|jpe?g|png)$' ] json = '["\\\\.(?i:gif|jpe?g|png)$"]' - assert_equal json, JSON.unparse(data) + assert_equal json, JSON.generate(data) assert_equal data, JSON.parse(json) # data = [ '\\"' ] json = '["\\\\\""]' - assert_equal json, JSON.unparse(data) + assert_equal json, JSON.generate(data) assert_equal data, JSON.parse(json) # json = '["/"]' data = JSON.parse(json) assert_equal ['/'], data - assert_equal json, JSON.unparse(data) + assert_equal json, JSON.generate(data) # json = '["\""]' data = JSON.parse(json) assert_equal ['"'], data - assert_equal json, JSON.unparse(data) + assert_equal json, JSON.generate(data) json = '["\\\'"]' data = JSON.parse(json) assert_equal ["'"], data - assert_equal '["\'"]', JSON.unparse(data) + assert_equal '["\'"]', JSON.generate(data) end def test_wrong_inputs @@ -287,6 +302,13 @@ EOT assert_equal too_deep, ok end + def test_symbolize_names + assert_equal({ "foo" => "bar", "baz" => "quux" }, + JSON.parse('{"foo":"bar", "baz":"quux"}')) + assert_equal({ :foo => "bar", :baz => "quux" }, + JSON.parse('{"foo":"bar", "baz":"quux"}', :symbolize_names => true)) + end + def test_load_dump too_deep = '[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]' assert_equal too_deep, JSON.dump(eval(too_deep)) @@ -302,4 +324,17 @@ EOT JSON.dump(eval(too_deep), output, 20) assert_equal too_deep, output.string end + + def test_big_integers + json1 = JSON([orig = (1 << 31) - 1]) + assert_equal orig, JSON[json1][0] + json2 = JSON([orig = 1 << 31]) + assert_equal orig, JSON[json2][0] + json3 = JSON([orig = (1 << 62) - 1]) + assert_equal orig, JSON[json3][0] + json4 = JSON([orig = 1 << 62]) + assert_equal orig, JSON[json4][0] + json5 = JSON([orig = 1 << 64]) + assert_equal orig, JSON[json5][0] + end end diff --git a/test/json/test_json_addition.rb b/test/json/test_json_addition.rb index 51e4a67f33..ec89c07e6d 100755 --- a/test/json/test_json_addition.rb +++ b/test/json/test_json_addition.rb @@ -95,7 +95,7 @@ class TC_JSONAddition < Test::Unit::TestCase c = C.new assert !C.json_creatable? json = generate(c) - assert_raises(ArgumentError) { JSON.parse(json) } + assert_raises(ArgumentError, NameError) { JSON.parse(json) } end def test_raw_strings @@ -110,11 +110,9 @@ class TC_JSONAddition < Test::Unit::TestCase json_raw_object = raw.to_json_raw_object hash = { 'json_class' => 'String', 'raw'=> raw_array } assert_equal hash, json_raw_object - json_raw = < true) + if defined?(::Encoding) + 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) } + end + end +end diff --git a/test/json/test_json_generate.rb b/test/json/test_json_generate.rb old mode 100644 new mode 100755 index bbb75ba524..26ca1adcf9 --- a/test/json/test_json_generate.rb +++ b/test/json/test_json_generate.rb @@ -44,8 +44,8 @@ class TC_JSONGenerate < Test::Unit::TestCase EOT end - def test_unparse - json = unparse(@hash) + def test_generate + json = generate(@hash) assert_equal(JSON.parse(@json2), JSON.parse(json)) parsed_json = parse(json) assert_equal(@hash, parsed_json) @@ -53,10 +53,11 @@ EOT assert_equal('{"1":2}', json) parsed_json = parse(json) assert_equal({"1"=>2}, parsed_json) + assert_raise(GeneratorError) { generate(666) } end - def test_unparse_pretty - json = pretty_unparse(@hash) + def test_generate_pretty + json = pretty_generate(@hash) assert_equal(JSON.parse(@json3), JSON.parse(json)) parsed_json = parse(json) assert_equal(@hash, parsed_json) @@ -68,38 +69,53 @@ EOT EOT parsed_json = parse(json) assert_equal({"1"=>2}, parsed_json) + assert_raise(GeneratorError) { pretty_generate(666) } + end + + def test_fast_generate + json = fast_generate(@hash) + assert_equal(JSON.parse(@json2), JSON.parse(json)) + parsed_json = parse(json) + assert_equal(@hash, parsed_json) + json = fast_generate({1=>2}) + assert_equal('{"1":2}', json) + parsed_json = parse(json) + assert_equal({"1"=>2}, parsed_json) + assert_raise(GeneratorError) { fast_generate(666) } end def test_states json = generate({1=>2}, nil) assert_equal('{"1":2}', json) - s = JSON.state.new(:check_circular => true) - #assert s.check_circular + s = JSON.state.new + assert s.check_circular? + assert s[:check_circular?] h = { 1=>2 } h[3] = h - assert_raises(JSON::CircularDatastructure) { generate(h) } - assert_raises(JSON::CircularDatastructure) { generate(h, s) } - s = JSON.state.new(:check_circular => true) - #assert s.check_circular + assert_raises(JSON::NestingError) { generate(h) } + assert_raises(JSON::NestingError) { generate(h, s) } + s = JSON.state.new a = [ 1, 2 ] a << a - assert_raises(JSON::CircularDatastructure) { generate(a, s) } + assert_raises(JSON::NestingError) { generate(a, s) } + assert s.check_circular? + assert s[:check_circular?] end def test_allow_nan assert_raises(GeneratorError) { generate([JSON::NaN]) } assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true) - assert_equal '[NaN]', fast_generate([JSON::NaN]) + assert_raises(GeneratorError) { fast_generate([JSON::NaN]) } assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) } assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true) assert_raises(GeneratorError) { generate([JSON::Infinity]) } assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true) - assert_equal '[Infinity]', fast_generate([JSON::Infinity]) + assert_raises(GeneratorError) { fast_generate([JSON::Infinity]) } assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) } assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true) assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) } assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true) - assert_equal '[-Infinity]', fast_generate([JSON::MinusInfinity]) + assert_raises(GeneratorError) { fast_generate([JSON::MinusInfinity]) } assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) } assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true) end diff --git a/test/json/test_json_rails.rb b/test/json/test_json_rails.rb old mode 100644 new mode 100755 index 341d3329ad..6fd201bc49 --- a/test/json/test_json_rails.rb +++ b/test/json/test_json_rails.rb @@ -116,7 +116,7 @@ class TC_JSONRails < Test::Unit::TestCase c = C.new # with rails addition all objects are theoretically creatable assert C.json_creatable? json = generate(c) - assert_raises(ArgumentError) { JSON.parse(json) } + assert_raises(ArgumentError, NameError) { JSON.parse(json) } end def test_raw_strings @@ -131,16 +131,14 @@ class TC_JSONRails < Test::Unit::TestCase json_raw_object = raw.to_json_raw_object hash = { 'json_class' => 'String', 'raw'=> raw_array } assert_equal hash, json_raw_object - json_raw = < false) + assert_equal utf8, parse(json) json = '["\u00a9 \u2260 \u20ac! \u0001"]' - assert_equal json, utf8.to_json + assert_equal json, utf8.to_json(:ascii_only => true) + assert_equal utf8, parse(json) + utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"] + json = "[\"\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212\"]" assert_equal utf8, parse(json) + assert_equal json, utf8.to_json(:ascii_only => false) utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"] + assert_equal utf8, parse(json) json = "[\"\\u3042\\u3044\\u3046\\u3048\\u304a\"]" - assert_equal json, utf8.to_json + assert_equal json, utf8.to_json(:ascii_only => true) assert_equal utf8, parse(json) utf8 = ['საქართველო'] + json = '["საქართველო"]' + assert_equal json, utf8.to_json(:ascii_only => false) json = "[\"\\u10e1\\u10d0\\u10e5\\u10d0\\u10e0\\u10d7\\u10d5\\u10d4\\u10da\\u10dd\"]" - assert_equal json, utf8.to_json + assert_equal json, utf8.to_json(:ascii_only => true) assert_equal utf8, parse(json) - assert_equal '["\\u00c3"]', JSON.generate(["Ã"]) + assert_equal '["Ã"]', JSON.generate(["Ã"], :ascii_only => false) + assert_equal '["\\u00c3"]', JSON.generate(["Ã"], :ascii_only => true) assert_equal ["€"], JSON.parse('["\u20ac"]') utf8 = ["\xf0\xa0\x80\x81"] + json = "[\"\xf0\xa0\x80\x81\"]" + assert_equal json, JSON.generate(utf8, :ascii_only => false) + assert_equal utf8, JSON.parse(json) json = '["\ud840\udc01"]' - assert_equal json, JSON.generate(utf8) + assert_equal json, JSON.generate(utf8, :ascii_only => true) assert_equal utf8, JSON.parse(json) end @@ -55,7 +69,7 @@ class TC_JSONUnicode < Test::Unit::TestCase end end assert_raise(JSON::GeneratorError) do - JSON.generate(["\x80"]) + JSON.generate(["\x80"], :ascii_only => true) end assert_equal "\302\200", JSON.parse('["\u0080"]').first end -- cgit v1.2.3