summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rwxr-xr-xtest/json/test_json.rb132
-rwxr-xr-xtest/json/test_json_addition.rb13
-rwxr-xr-xtest/json/test_json_fixtures.rb9
-rw-r--r--test/json/test_json_generate.rb27
-rw-r--r--test/json/test_json_rails.rb36
-rwxr-xr-xtest/json/test_json_unicode.rb6
6 files changed, 153 insertions, 70 deletions
diff --git a/test/json/test_json.rb b/test/json/test_json.rb
index ae77f7b14fb..53076095f7c 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
diff --git a/test/json/test_json_addition.rb b/test/json/test_json_addition.rb
index 2650db68f08..51e4a67f330 100755
--- a/test/json/test_json_addition.rb
+++ b/test/json/test_json_addition.rb
@@ -1,6 +1,12 @@
#!/usr/bin/env ruby
+# -*- coding:utf-8 -*-
require 'test/unit'
+case ENV['JSON']
+when 'pure' then require 'json/pure'
+when 'ext' then require 'json/ext'
+else require 'json'
+end
require 'json/add/core'
require 'date'
@@ -17,7 +23,7 @@ class TC_JSONAddition < Test::Unit::TestCase
def ==(other)
a == other.a
end
-
+
def self.json_create(object)
new(*object['args'])
end
@@ -89,11 +95,12 @@ class TC_JSONAddition < Test::Unit::TestCase
c = C.new
assert !C.json_creatable?
json = generate(c)
- assert_raise(ArgumentError) { JSON.parse(json) }
+ assert_raises(ArgumentError) { JSON.parse(json) }
end
def test_raw_strings
raw = ''
+ raw.respond_to?(:encode!) and raw.encode!(Encoding::ASCII_8BIT)
raw_array = []
for i in 0..255
raw << i
@@ -129,7 +136,7 @@ EOT
assert_equal s, JSON(JSON(s))
struct = Struct.new :foo, :bar
s = struct.new 4711, 'foot'
- assert_raise(JSONError) { JSON(s) }
+ assert_raises(JSONError) { JSON(s) }
begin
raise TypeError, "test me"
rescue TypeError => e
diff --git a/test/json/test_json_fixtures.rb b/test/json/test_json_fixtures.rb
index 6cc1bfc6fab..95e57ebfdcf 100755
--- a/test/json/test_json_fixtures.rb
+++ b/test/json/test_json_fixtures.rb
@@ -1,7 +1,12 @@
#!/usr/bin/env ruby
+# -*- 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
class TC_JSONFixtures < Test::Unit::TestCase
def setup
@@ -20,7 +25,7 @@ class TC_JSONFixtures < Test::Unit::TestCase
def test_failing
for name, source in @failed
- assert_raise(JSON::ParserError, JSON::NestingError,
+ assert_raises(JSON::ParserError, JSON::NestingError,
"Did not fail for fixture '#{name}'") do
JSON.parse(source)
end
diff --git a/test/json/test_json_generate.rb b/test/json/test_json_generate.rb
index 8c55a409cd3..bbb75ba5244 100644
--- a/test/json/test_json_generate.rb
+++ b/test/json/test_json_generate.rb
@@ -1,5 +1,12 @@
+#!/usr/bin/env ruby
+# -*- 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
class TC_JSONGenerate < Test::Unit::TestCase
include JSON
@@ -70,30 +77,30 @@ EOT
#assert s.check_circular
h = { 1=>2 }
h[3] = h
- assert_raise(JSON::CircularDatastructure) { generate(h) }
- assert_raise(JSON::CircularDatastructure) { generate(h, s) }
+ assert_raises(JSON::CircularDatastructure) { generate(h) }
+ assert_raises(JSON::CircularDatastructure) { generate(h, s) }
s = JSON.state.new(:check_circular => true)
#assert s.check_circular
a = [ 1, 2 ]
a << a
- assert_raise(JSON::CircularDatastructure) { generate(a, s) }
+ assert_raises(JSON::CircularDatastructure) { generate(a, s) }
end
def test_allow_nan
- assert_raise(GeneratorError) { generate([JSON::NaN]) }
+ assert_raises(GeneratorError) { generate([JSON::NaN]) }
assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
assert_equal '[NaN]', fast_generate([JSON::NaN])
- assert_raise(GeneratorError) { pretty_generate([JSON::NaN]) }
+ assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) }
assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
- assert_raise(GeneratorError) { generate([JSON::Infinity]) }
+ assert_raises(GeneratorError) { generate([JSON::Infinity]) }
assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
assert_equal '[Infinity]', fast_generate([JSON::Infinity])
- assert_raise(GeneratorError) { pretty_generate([JSON::Infinity]) }
+ assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) }
assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
- assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) }
+ assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) }
assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
assert_equal '[-Infinity]', fast_generate([JSON::MinusInfinity])
- assert_raise(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
+ assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
end
end
diff --git a/test/json/test_json_rails.rb b/test/json/test_json_rails.rb
index 91eb9ee9ea0..341d3329ad3 100644
--- a/test/json/test_json_rails.rb
+++ b/test/json/test_json_rails.rb
@@ -1,6 +1,12 @@
#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
require 'test/unit'
+case ENV['JSON']
+when 'pure' then require 'json/pure'
+when 'ext' then require 'json/ext'
+else require 'json'
+end
require 'json/add/rails'
require 'date'
@@ -17,7 +23,7 @@ class TC_JSONRails < Test::Unit::TestCase
def ==(other)
a == other.a
end
-
+
def self.json_create(object)
new(*object['args'])
end
@@ -50,13 +56,38 @@ class TC_JSONRails < Test::Unit::TestCase
end
end
+ class D
+ def initialize
+ @foo = 666
+ end
+
+ attr_reader :foo
+
+ def ==(other)
+ foo == other.foo
+ end
+ end
+
def test_extended_json
a = A.new(666)
assert A.json_creatable?
+ assert_equal 666, a.a
json = generate(a)
a_again = JSON.parse(json)
assert_kind_of a.class, a_again
assert_equal a, a_again
+ assert_equal 666, a_again.a
+ end
+
+ def test_extended_json_generic_object
+ d = D.new
+ assert D.json_creatable?
+ assert_equal 666, d.foo
+ json = generate(d)
+ d_again = JSON.parse(json)
+ assert_kind_of d.class, d_again
+ assert_equal d, d_again
+ assert_equal 666, d_again.foo
end
def test_extended_json_disabled
@@ -85,11 +116,12 @@ 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_raise(ArgumentError) { JSON.parse(json) }
+ assert_raises(ArgumentError) { JSON.parse(json) }
end
def test_raw_strings
raw = ''
+ raw.respond_to?(:encode!) and raw.encode!(Encoding::ASCII_8BIT)
raw_array = []
for i in 0..255
raw << i
diff --git a/test/json/test_json_unicode.rb b/test/json/test_json_unicode.rb
index b8a37c8b8d2..1454fe197d7 100755
--- a/test/json/test_json_unicode.rb
+++ b/test/json/test_json_unicode.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
class TC_JSONUnicode < Test::Unit::TestCase
include JSON