2 # -*- coding: utf-8 -*-
5 require File.join(File.dirname(__FILE__), 'setup_variant')
7 class TC_JSONGenerate < Test::Unit::TestCase
15 'd' => [ 1, "b", 3.14 ],
16 'e' => { 'foo' => 'bar' },
21 @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
22 '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
23 @json3 = <<'EOT'.chomp
36 "g": "\"\u0000\u001f",
44 json = generate(@hash)
45 assert_equal(JSON.parse(@json2), JSON.parse(json))
46 parsed_json = parse(json)
47 assert_equal(@hash, parsed_json)
48 json = generate({1=>2})
49 assert_equal('{"1":2}', json)
50 parsed_json = parse(json)
51 assert_equal({"1"=>2}, parsed_json)
52 assert_raise(GeneratorError) { generate(666) }
53 assert_equal '666', generate(666, :quirks_mode => true)
56 def test_generate_pretty
57 json = pretty_generate(@hash)
58 # hashes aren't (insertion) ordered on every ruby implementation assert_equal(@json3, json)
59 assert_equal(JSON.parse(@json3), JSON.parse(json))
60 parsed_json = parse(json)
61 assert_equal(@hash, parsed_json)
62 json = pretty_generate({1=>2})
63 assert_equal(<<'EOT'.chomp, json)
68 parsed_json = parse(json)
69 assert_equal({"1"=>2}, parsed_json)
70 assert_raise(GeneratorError) { pretty_generate(666) }
71 assert_equal '666', pretty_generate(666, :quirks_mode => true)
74 def test_fast_generate
75 json = fast_generate(@hash)
76 assert_equal(JSON.parse(@json2), JSON.parse(json))
77 parsed_json = parse(json)
78 assert_equal(@hash, parsed_json)
79 json = fast_generate({1=>2})
80 assert_equal('{"1":2}', json)
81 parsed_json = parse(json)
82 assert_equal({"1"=>2}, parsed_json)
83 assert_raise(GeneratorError) { fast_generate(666) }
84 assert_equal '666', fast_generate(666, :quirks_mode => true)
89 json = generate(@hash, state)
90 assert_equal(JSON.parse(@json2), JSON.parse(json))
91 parsed_json = parse(json)
92 assert_equal(@hash, parsed_json)
93 json = generate({1=>2}, state)
94 assert_equal('{"1":2}', json)
95 parsed_json = parse(json)
96 assert_equal({"1"=>2}, parsed_json)
97 assert_raise(GeneratorError) { generate(666, state) }
98 state.quirks_mode = true
99 assert state.quirks_mode?
100 assert_equal '666', generate(666, state)
104 json = generate({1=>2}, nil)
105 assert_equal('{"1":2}', json)
107 assert s.check_circular?
108 assert s[:check_circular?]
111 assert_raises(JSON::NestingError) { generate(h) }
112 assert_raises(JSON::NestingError) { generate(h, s) }
116 assert_raises(JSON::NestingError) { generate(a, s) }
117 assert s.check_circular?
118 assert s[:check_circular?]
121 def test_pretty_state
122 state = PRETTY_STATE_PROTOTYPE.dup
126 :ascii_only => false,
127 :quirks_mode => false,
134 }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
138 state = SAFE_STATE_PROTOTYPE.dup
142 :ascii_only => false,
143 :quirks_mode => false,
150 }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
154 state = FAST_STATE_PROTOTYPE.dup
158 :ascii_only => false,
159 :quirks_mode => false,
166 }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
170 assert_raises(GeneratorError) { generate([JSON::NaN]) }
171 assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
172 assert_raises(GeneratorError) { fast_generate([JSON::NaN]) }
173 assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) }
174 assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
175 assert_raises(GeneratorError) { generate([JSON::Infinity]) }
176 assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
177 assert_raises(GeneratorError) { fast_generate([JSON::Infinity]) }
178 assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) }
179 assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
180 assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) }
181 assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
182 assert_raises(GeneratorError) { fast_generate([JSON::MinusInfinity]) }
183 assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
184 assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
189 assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
190 assert_raises(JSON::NestingError) { JSON.generate(ary) }
191 assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
192 assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
193 assert_raises(JSON::NestingError) { JSON.pretty_generate(ary) }
194 assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
196 assert_equal 0, s.depth
197 assert_raises(JSON::NestingError) { ary.to_json(s) }
198 assert_equal 19, s.depth
202 bignum_too_long_to_embed_as_string = 1234567890123456789012345
203 expect = bignum_too_long_to_embed_as_string.to_s
204 stress, GC.stress = GC.stress, true
207 tmp = bignum_too_long_to_embed_as_string.to_json
208 assert_equal expect, tmp
212 end if GC.respond_to?(:stress=)