lib/mcollective/vendor/json/tests/test_json_generate.rb

   1 #!/usr/bin/env ruby
   2 # -*- coding: utf-8 -*-
   3
   4 require 'test/unit'
   5 require File.join(File.dirname(__FILE__), 'setup_variant')
   6
   7 class TC_JSONGenerate < Test::Unit::TestCase
   8   include JSON
   9
  10   def setup
  11     @hash = {
  12       'a' => 2,
  13       'b' => 3.141,
  14       'c' => 'c',
  15       'd' => [ 1, "b", 3.14 ],
  16       'e' => { 'foo' => 'bar' },
  17       'g' => "\"\0\037",
  18       'h' => 1000.0,
  19       'i' => 0.001
  20     }
  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
  24 {
  25   "a": 2,
  26   "b": 3.141,
  27   "c": "c",
  28   "d": [
  29     1,
  30     "b",
  31     3.14
  32   ],
  33   "e": {
  34     "foo": "bar"
  35   },
  36   "g": "\"\u0000\u001f",
  37   "h": 1000.0,
  38   "i": 0.001
  39 }
  40 EOT
  41   end
  42
  43   def test_generate
  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)
  54   end
  55
  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)
  64 {
  65   "1": 2
  66 }
  67 EOT
  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)
  72   end
  73
  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)
  85   end
  86
  87   def test_own_state
  88     state = State.new
  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)
 101   end
 102
 103   def test_states
 104     json = generate({1=>2}, nil)
 105     assert_equal('{"1":2}', json)
 106     s = JSON.state.new
 107     assert s.check_circular?
 108     assert s[:check_circular?]
 109     h = { 1=>2 }
 110     h[3] = h
 111     assert_raises(JSON::NestingError) {  generate(h) }
 112     assert_raises(JSON::NestingError) {  generate(h, s) }
 113     s = JSON.state.new
 114     a = [ 1, 2 ]
 115     a << a
 116     assert_raises(JSON::NestingError) {  generate(a, s) }
 117     assert s.check_circular?
 118     assert s[:check_circular?]
 119   end
 120
 121   def test_pretty_state
 122     state = PRETTY_STATE_PROTOTYPE.dup
 123     assert_equal({
 124       :allow_nan    => false,
 125       :array_nl     => "\n",
 126       :ascii_only   => false,
 127       :quirks_mode  => false,
 128       :depth        => 0,
 129       :indent       => "  ",
 130       :max_nesting  => 19,
 131       :object_nl    => "\n",
 132       :space        => " ",
 133       :space_before => "",
 134     }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
 135   end
 136
 137   def test_safe_state
 138     state = SAFE_STATE_PROTOTYPE.dup
 139     assert_equal({
 140       :allow_nan    => false,
 141       :array_nl     => "",
 142       :ascii_only   => false,
 143       :quirks_mode  => false,
 144       :depth        => 0,
 145       :indent       => "",
 146       :max_nesting  => 19,
 147       :object_nl    => "",
 148       :space        => "",
 149       :space_before => "",
 150     }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
 151   end
 152
 153   def test_fast_state
 154     state = FAST_STATE_PROTOTYPE.dup
 155     assert_equal({
 156       :allow_nan    => false,
 157       :array_nl     => "",
 158       :ascii_only   => false,
 159       :quirks_mode  => false,
 160       :depth        => 0,
 161       :indent       => "",
 162       :max_nesting  => 0,
 163       :object_nl    => "",
 164       :space        => "",
 165       :space_before => "",
 166     }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
 167   end
 168
 169   def test_allow_nan
 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)
 185   end
 186
 187   def test_depth
 188     ary = []; ary << ary
 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
 195     s = JSON.state.new
 196     assert_equal 0, s.depth
 197     assert_raises(JSON::NestingError) { ary.to_json(s) }
 198     assert_equal 19, s.depth
 199   end
 200
 201   def test_gc
 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
 205
 206     10.times do |i|
 207       tmp = bignum_too_long_to_embed_as_string.to_json
 208       assert_equal expect, tmp
 209     end
 210   ensure
 211     GC.stress = stress
 212   end if GC.respond_to?(:stress=)
 213 end