oj 2.18.3 → 3.13.14

data/test/json_gem/json_encoding_test.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#frozen_string_literal: false
+
+require 'json_gem/test_helper'
+
+class JSONEncodingTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+  include Test::Unit::TestCasePendingSupport
+
+  def setup
+    @utf_8      = '"© ≠ €!"'
+    @ascii_8bit = @utf_8.dup.force_encoding('ascii-8bit')
+    @parsed     = "© ≠ €!"
+    @generated  = '"\u00a9 \u2260 \u20ac!"'
+    if String.method_defined?(:encode)
+      @utf_16_data = @parsed.encode('utf-16be', 'utf-8')
+      @utf_16be = @utf_8.encode('utf-16be', 'utf-8')
+      @utf_16le = @utf_8.encode('utf-16le', 'utf-8')
+      @utf_32be = @utf_8.encode('utf-32be', 'utf-8')
+      @utf_32le = @utf_8.encode('utf-32le', 'utf-8')
+    else
+      require 'iconv'
+      @utf_16_data, = Iconv.iconv('utf-16be', 'utf-8', @parsed)
+      @utf_16be, = Iconv.iconv('utf-16be', 'utf-8', @utf_8)
+      @utf_16le, = Iconv.iconv('utf-16le', 'utf-8', @utf_8)
+      @utf_32be, = Iconv.iconv('utf-32be', 'utf-8', @utf_8)
+      @utf_32le, = Iconv.iconv('utf-32le', 'utf-8', @utf_8)
+    end
+  end
+
+  def test_parse
+    assert_equal @parsed, JSON.parse(@ascii_8bit)
+    assert_equal @parsed, JSON.parse(@utf_8)
+    assert_equal @parsed, JSON.parse(@utf_16be)
+    assert_equal @parsed, JSON.parse(@utf_16le)
+    assert_equal @parsed, JSON.parse(@utf_32be)
+    assert_equal @parsed, JSON.parse(@utf_32le)
+  end
+
+  def test_generate
+    assert_equal @generated, JSON.generate(@parsed, :ascii_only => true)
+    assert_equal @generated, JSON.generate(@utf_16_data, :ascii_only => true)
+  end
+
+  def test_unicode
+    assert_equal '""', ''.to_json
+    assert_equal '"\\b"', "\b".to_json
+    assert_equal '"\u0001"', 0x1.chr.to_json
+    assert_equal '"\u001f"', 0x1f.chr.to_json
+    assert_equal '" "', ' '.to_json
+    assert_equal "\"#{0x7f.chr}\"", 0x7f.chr.to_json
+    utf8 = [ "© ≠ €! \01" ]
+    json = '["© ≠ €! \u0001"]'
+    assert_equal json, utf8.to_json(:ascii_only => false)
+    assert_equal utf8, JSON.parse(json)
+    json = '["\u00a9 \u2260 \u20ac! \u0001"]'
+    assert_equal json, utf8.to_json(:ascii_only => true)
+    assert_equal utf8, JSON.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, JSON.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, JSON.parse(json)
+    json = "[\"\\u3042\\u3044\\u3046\\u3048\\u304a\"]"
+    assert_equal json, utf8.to_json(:ascii_only => true)
+    assert_equal utf8, JSON.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(:ascii_only => true)
+    assert_equal utf8, JSON.parse(json)
+    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, :ascii_only => true)
+    assert_equal utf8, JSON.parse(json)
+  end
+
+  def test_chars
+    (0..0x7f).each do |i|
+      json = '["\u%04x"]' % i
+      i = i.chr
+      assert_equal i, JSON.parse(json).first[0]
+      if i == ?\b
+        generated = JSON.generate(["" << i])
+        assert '["\b"]' == generated || '["\10"]' == generated
+      elsif [?\n, ?\r, ?\t, ?\f].include?(i)
+        assert_equal '[' << ('' << i).dump << ']', JSON.generate(["" << i])
+      elsif i.chr < 0x20.chr
+        assert_equal json, JSON.generate(["" << i])
+      end
+    end
+    assert_raise(JSON::GeneratorError) do
+      JSON.generate(["\x80"], :ascii_only => true)
+    end
+    assert_equal "\302\200", JSON.parse('["\u0080"]').first
+  end
+end

data/test/json_gem/json_ext_parser_test.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#frozen_string_literal: false
+require 'json_gem/test_helper'
+
+class JSONExtParserTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+
+  if defined?(JSON::Ext::Parser)
+    def test_allocate
+      parser = JSON::Ext::Parser.new("{}")
+      assert_raise(TypeError, '[ruby-core:35079]') do
+        parser.__send__(:initialize, "{}")
+      end
+      parser = JSON::Ext::Parser.allocate
+      assert_raise(TypeError, '[ruby-core:35079]') { parser.source }
+    end
+  end
+end

data/test/json_gem/json_fixtures_test.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#frozen_string_literal: false
+require 'json_gem/test_helper'
+
+class JSONFixturesTest < Test::Unit::TestCase
+  def setup
+    fixtures = File.join(File.dirname(__FILE__), 'fixtures/{fail,pass}.json')
+    passed, failed = Dir[fixtures].partition { |f| f['pass'] }
+    @passed = passed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+    @failed = failed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+  end
+
+  def test_passing
+    for name, source in @passed
+      begin
+        assert JSON.parse(source),
+          "Did not pass for fixture '#{name}': #{source.inspect}"
+      rescue => e
+        warn "\nCaught #{e.class}(#{e}) for fixture '#{name}': #{source.inspect}\n#{e.backtrace * "\n"}"
+        raise e
+      end
+    end
+  end
+
+  def test_failing
+    for name, source in @failed
+      assert_raise(JSON::ParserError, JSON::NestingError,
+        "Did not fail for fixture '#{name}': #{source.inspect}") do
+        JSON.parse(source)
+      end
+    end
+  end
+end

data/test/json_gem/json_generator_test.rb

@@ -0,0 +1,397 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+# frozen_string_literal: false
+
+require 'json_gem/test_helper'
+
+class JSONGeneratorTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+  include Test::Unit::TestCasePendingSupport
+
+  def setup
+    @hash = {
+      'a' => 2,
+      'b' => 3.141,
+      'c' => 'c',
+      'd' => [ 1, "b", 3.14 ],
+      'e' => { 'foo' => 'bar' },
+      'g' => "\"\0\037",
+      'h' => 1000.0,
+      'i' => 0.001
+    }
+    @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
+      '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+    @json3 = <<'EOT'.chomp
+{
+  "a": 2,
+  "b": 3.141,
+  "c": "c",
+  "d": [
+    1,
+    "b",
+    3.14
+  ],
+  "e": {
+    "foo": "bar"
+  },
+  "g": "\"\u0000\u001f",
+  "h": 1000.0,
+  "i": 0.001
+}
+EOT
+  end
+
+  def test_generate
+    json = JSON.generate(@hash)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    json = JSON[@hash]
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    parsed_json = JSON.parse(json)
+    assert_equal(@hash, parsed_json)
+    json = JSON.generate({1=>2})
+    assert_equal('{"1":2}', json)
+    parsed_json = JSON.parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_equal '666', JSON.generate(666)
+  end
+
+  def test_generate_pretty
+    json = JSON.pretty_generate(@hash)
+    # hashes aren't (insertion) ordered on every ruby implementation
+    assert_equal(@json3, json)
+    assert_equal(JSON.parse(@json3), JSON.parse(json))
+    parsed_json = JSON.parse(json)
+    assert_equal(@hash, parsed_json)
+    json = JSON.pretty_generate({1=>2})
+    assert_equal(<<'EOT'.chomp, json)
+{
+  "1": 2
+}
+EOT
+    parsed_json = JSON.parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_equal '666', JSON.pretty_generate(666)
+    json_nil_opts = JSON.pretty_generate({1=>2}, nil)
+    assert_equal json, json_nil_opts
+  end
+
+  def test_generate_custom
+    state = JSON::State.new(:space_before => " ", :space => "   ", :indent => "<i>", :object_nl => "\n", :array_nl => "<a_nl>")
+    json = JSON.generate({1=>{2=>3,4=>[5,6]}}, state)
+    assert_equal(<<'EOT'.chomp, json)
+{
+<i>"1" :   {
+<i><i>"2" :   3,
+<i><i>"4" :   [<a_nl><i><i><i>5,<a_nl><i><i><i>6<a_nl><i><i>]
+<i>}
+}
+EOT
+  end
+
+  def test_fast_generate
+    json = JSON.fast_generate(@hash)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    parsed_json = JSON.parse(json)
+    assert_equal(@hash, parsed_json)
+    json = JSON.fast_generate({1=>2})
+    assert_equal('{"1":2}', json)
+    parsed_json = JSON.parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_equal '666', JSON.fast_generate(666)
+  end
+
+  def test_own_state
+    state = JSON::State.new
+    json = JSON.generate(@hash, state)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    parsed_json = JSON.parse(json)
+    assert_equal(@hash, parsed_json)
+    json = JSON.generate({1=>2}, state)
+    assert_equal('{"1":2}', json)
+    parsed_json = JSON.parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_equal '666', JSON.generate(666, state)
+  end
+
+  # TBD Implement JSON.state to return state class.
+  # set state attributes from defaults
+  # implement methods
+  # circular should use circular in defaults or maybe always set to true, allow changes with [:check_circular]=
+  def test_states
+    json = JSON.generate({1=>2}, nil)
+    assert_equal('{"1":2}', json)
+    s = JSON.state.new
+    assert s.check_circular?
+    assert s[:check_circular?]
+    h = { 1=>2 }
+    h[3] = h
+    assert_raise(JSON::NestingError) {  JSON.generate(h) }
+    assert_raise(JSON::NestingError) {  JSON.generate(h, s) }
+    s = JSON.state.new
+    a = [ 1, 2 ]
+    a << a
+    assert_raise(JSON::NestingError) {  JSON.generate(a, s) }
+    assert s.check_circular?
+    assert s[:check_circular?]
+  end
+
+  def test_pretty_state
+    state = JSON::PRETTY_STATE_PROTOTYPE.dup
+    # In come cases in Ruby 3.0 an :escape_slash is included in the state. It
+    # seems to occur on travis but not locally.
+    actual = state.to_h
+    actual.delete(:escape_slash)
+    assert_equal({
+      :allow_nan             => false,
+      :array_nl              => "\n",
+      :ascii_only            => false,
+      :buffer_initial_length => 1024,
+      :depth                 => 0,
+      :indent                => "  ",
+      :max_nesting           => 100,
+      :object_nl             => "\n",
+      :space                 => " ",
+      :space_before          => "",
+    }.sort_by { |n,| n.to_s }, actual.sort_by { |n,| n.to_s })
+  end
+
+  def test_safe_state
+    state = JSON::SAFE_STATE_PROTOTYPE.dup
+    # In come cases in Ruby 3.0 an :escape_slash is included in the state. It
+    # seems to occur on travis but not locally.
+    actual = state.to_h
+    actual.delete(:escape_slash)
+    assert_equal({
+      :allow_nan             => false,
+      :array_nl              => "",
+      :ascii_only            => false,
+      :buffer_initial_length => 1024,
+      :depth                 => 0,
+      :indent                => "",
+      :max_nesting           => 100,
+      :object_nl             => "",
+      :space                 => "",
+      :space_before          => "",
+    }.sort_by { |n,| n.to_s }, actual.sort_by { |n,| n.to_s })
+  end
+
+  def test_fast_state
+    state = JSON::FAST_STATE_PROTOTYPE.dup
+    # In come cases in Ruby 3.0 an :escape_slash is included in the state. It
+    # seems to occur on travis but not locally.
+    actual = state.to_h
+    actual.delete(:escape_slash)
+    assert_equal({
+      :allow_nan             => false,
+      :array_nl              => "",
+      :ascii_only            => false,
+      :buffer_initial_length => 1024,
+      :depth                 => 0,
+      :indent                => "",
+      :max_nesting           => 0,
+      :object_nl             => "",
+      :space                 => "",
+      :space_before          => "",
+    }.sort_by { |n,| n.to_s }, actual.sort_by { |n,| n.to_s })
+  end
+
+  def test_allow_nan
+    assert_raise(JSON::GeneratorError) { JSON.generate([JSON::NaN]) }
+    assert_equal '[NaN]', JSON.generate([JSON::NaN], :allow_nan => true)
+    assert_raise(JSON::GeneratorError) { JSON.fast_generate([JSON::NaN]) }
+    assert_raise(JSON::GeneratorError) { JSON.pretty_generate([JSON::NaN]) }
+    assert_equal "[\n  NaN\n]", JSON.pretty_generate([JSON::NaN], :allow_nan => true)
+    assert_raise(JSON::GeneratorError) { JSON.generate([JSON::Infinity]) }
+    assert_equal '[Infinity]', JSON.generate([JSON::Infinity], :allow_nan => true)
+    assert_raise(JSON::GeneratorError) { JSON.fast_generate([JSON::Infinity]) }
+    assert_raise(JSON::GeneratorError) { JSON.pretty_generate([JSON::Infinity]) }
+    assert_equal "[\n  Infinity\n]", JSON.pretty_generate([JSON::Infinity], :allow_nan => true)
+    assert_raise(JSON::GeneratorError) { JSON.generate([JSON::MinusInfinity]) }
+    assert_equal '[-Infinity]', JSON.generate([JSON::MinusInfinity], :allow_nan => true)
+    assert_raise(JSON::GeneratorError) { JSON.fast_generate([JSON::MinusInfinity]) }
+    assert_raise(JSON::GeneratorError) { JSON.pretty_generate([JSON::MinusInfinity]) }
+    assert_equal "[\n  -Infinity\n]", JSON.pretty_generate([JSON::MinusInfinity], :allow_nan => true)
+  end
+
+  def test_depth
+    ary = []; ary << ary
+    assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
+    assert_raise(JSON::NestingError) { JSON.generate(ary) }
+    assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
+    assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
+    assert_raise(JSON::NestingError) { JSON.pretty_generate(ary) }
+    assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
+    s = JSON.state.new
+    assert_equal 0, s.depth
+    assert_raise(JSON::NestingError) { ary.to_json(s) }
+    assert_equal 100, s.depth
+  end
+
+  def test_buffer_initial_length
+    s = JSON.state.new
+    assert_equal 1024, s.buffer_initial_length
+    s.buffer_initial_length = 0
+    assert_equal 1024, s.buffer_initial_length
+    s.buffer_initial_length = -1
+    assert_equal 1024, s.buffer_initial_length
+    s.buffer_initial_length = 128
+    assert_equal 128, s.buffer_initial_length
+  end
+
+  def test_gc
+    if respond_to?(:assert_in_out_err)
+      assert_in_out_err(%w[-rjson --disable-gems], <<-EOS, [], [])
+        bignum_too_long_to_embed_as_string = 1234567890123456789012345
+        expect = bignum_too_long_to_embed_as_string.to_s
+        GC.stress = true
+
+        10.times do |i|
+          tmp = bignum_too_long_to_embed_as_string.to_json
+          raise "'\#{expect}' is expected, but '\#{tmp}'" unless tmp == expect
+        end
+      EOS
+    end
+  end if GC.respond_to?(:stress=)
+
+  def test_configure_using_configure_and_merge
+    numbered_state = {
+      :indent       => "1",
+      :space        => '2',
+      :space_before => '3',
+      :object_nl    => '4',
+      :array_nl     => '5'
+    }
+    state1 = JSON.state.new
+    state1.merge(numbered_state)
+    assert_equal '1', state1.indent
+    assert_equal '2', state1.space
+    assert_equal '3', state1.space_before
+    assert_equal '4', state1.object_nl
+    assert_equal '5', state1.array_nl
+    state2 = JSON.state.new
+    state2.configure(numbered_state)
+    assert_equal '1', state2.indent
+    assert_equal '2', state2.space
+    assert_equal '3', state2.space_before
+    assert_equal '4', state2.object_nl
+    assert_equal '5', state2.array_nl
+  end
+
+  def test_configure_hash_conversion
+    state = JSON.state.new
+    state.configure(:indent => '1')
+    assert_equal '1', state.indent
+    state = JSON.state.new
+    foo = 'foo'
+    assert_raise(TypeError) do
+      state.configure(foo)
+    end
+    def foo.to_h
+      { :indent => '2' }
+    end
+    state.configure(foo)
+    assert_equal '2', state.indent
+  end
+
+  if defined?(JSON::Ext::Generator)
+    def test_broken_bignum # [ruby-core:38867]
+      pid = fork do
+        x = 1 << 64
+        x.class.class_eval do
+          def to_s
+          end
+        end
+        begin
+          j = JSON::Ext::Generator::State.new.generate(x)
+          exit 1
+        rescue TypeError
+          exit 0
+        end
+      end
+      _, status = Process.waitpid2(pid)
+      assert status.success?
+    rescue NotImplementedError
+      # forking to avoid modifying core class of a parent process and
+      # introducing race conditions of tests are run in parallel
+    end
+  end
+
+  def test_hash_likeness_set_symbol
+    state = JSON.state.new
+    assert_equal nil, state[:foo]
+    assert_equal nil.class, state[:foo].class
+    assert_equal nil, state['foo']
+    state[:foo] = :bar
+    assert_equal :bar, state[:foo]
+    assert_equal :bar, state['foo']
+    state_hash = state.to_hash
+    assert_kind_of Hash, state_hash
+    assert_equal :bar, state_hash[:foo]
+  end
+
+  def test_hash_likeness_set_string
+    state = JSON.state.new
+    assert_equal nil, state[:foo]
+    assert_equal nil, state['foo']
+    state['foo'] = :bar
+    assert_equal :bar, state[:foo]
+    assert_equal :bar, state['foo']
+    state_hash = state.to_hash
+    assert_kind_of Hash, state_hash
+    assert_equal :bar, state_hash[:foo]
+  end
+
+  def test_json_generate
+    assert_raise JSON::GeneratorError do
+      assert_equal true, JSON.generate(["\xea"])
+    end
+  end
+
+  def test_nesting
+    too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
+    too_deep_ary = eval too_deep
+    assert_raise(JSON::NestingError) { JSON.generate too_deep_ary }
+    assert_raise(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 100 }
+    ok = JSON.generate too_deep_ary, :max_nesting => 101
+    assert_equal too_deep, ok
+    ok = JSON.generate too_deep_ary, :max_nesting => nil
+    assert_equal too_deep, ok
+    ok = JSON.generate too_deep_ary, :max_nesting => false
+    assert_equal too_deep, ok
+    ok = JSON.generate too_deep_ary, :max_nesting => 0
+    assert_equal too_deep, ok
+  end
+
+  def test_backslash
+    data = [ '\\.(?i:gif|jpe?g|png)$' ]
+    json = '["\\\\.(?i:gif|jpe?g|png)$"]'
+    assert_equal json, JSON.generate(data)
+    #
+    data = [ '\\"' ]
+    json = '["\\\\\""]'
+    assert_equal json, JSON.generate(data)
+    #
+    data = [ '/' ]
+    json = '["/"]'
+    assert_equal json, JSON.generate(data)
+    #
+    data = ['"']
+    json = '["\""]'
+    assert_equal json, JSON.generate(data)
+    #
+    data = ["'"]
+    json = '["\\\'"]'
+    assert_equal '["\'"]', JSON.generate(data)
+  end
+
+  def test_string_subclass
+    s = Class.new(String) do
+      def to_s; self; end
+      undef to_json
+    end
+    assert_nothing_raised(SystemStackError) do
+      assert_equal '["foo"]', JSON.generate([s.new('foo')])
+    end
+  end
+end

data/test/json_gem/json_generic_object_test.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#frozen_string_literal: false
+
+require 'json_gem/test_helper'
+
+class JSONGenericObjectTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+
+  def setup
+    @go = JSON::GenericObject[ :a => 1, :b => 2 ]
+  end
+
+  def test_attributes
+    assert_equal 1, @go.a
+    assert_equal 1, @go[:a]
+    assert_equal 2, @go.b
+    assert_equal 2, @go[:b]
+    assert_nil @go.c
+    assert_nil @go[:c]
+  end 
+
+  def test_generate_json
+    switch_json_creatable do
+      assert_equal @go, JSON(JSON(@go), :create_additions => true)
+    end
+  end
+
+  def test_parse_json
+    x = JSON(
+        '{ "json_class": "JSON::GenericObject", "a": 1, "b": 2 }',
+        :create_additions => true
+             )
+    assert_kind_of Hash,
+      JSON(
+        '{ "json_class": "JSON::GenericObject", "a": 1, "b": 2 }',
+        :create_additions => true
+      )
+    switch_json_creatable do
+      assert_equal @go, l =
+        JSON(
+          '{ "json_class": "JSON::GenericObject", "a": 1, "b": 2 }',
+             :create_additions => true
+        )
+      assert_equal 1, l.a
+      assert_equal @go,
+        l = JSON('{ "a": 1, "b": 2 }', :object_class => JSON::GenericObject)
+      assert_equal 1, l.a
+      assert_equal JSON::GenericObject[:a => JSON::GenericObject[:b => 2]],
+        l = JSON('{ "a": { "b": 2 } }', :object_class => JSON::GenericObject)
+      assert_equal 2, l.a.b
+    end
+  end
+
+  def test_from_hash
+    result  = JSON::GenericObject.from_hash(
+      :foo => { :bar => { :baz => true }, :quux => [ { :foobar => true } ] })
+    assert_kind_of JSON::GenericObject, result.foo
+    assert_kind_of JSON::GenericObject, result.foo.bar
+    assert_equal   true, result.foo.bar.baz
+    assert_kind_of JSON::GenericObject, result.foo.quux.first
+    assert_equal   true, result.foo.quux.first.foobar
+    assert_equal   true, JSON::GenericObject.from_hash(true)
+  end
+
+  def test_json_generic_object_load
+    empty = JSON::GenericObject.load(nil)
+    assert_kind_of JSON::GenericObject, empty
+    simple_json = '{"json_class":"JSON::GenericObject","hello":"world"}'
+    simple = JSON::GenericObject.load(simple_json)
+    assert_kind_of JSON::GenericObject, simple
+    assert_equal "world", simple.hello
+    converting = JSON::GenericObject.load('{ "hello": "world" }')
+    assert_kind_of JSON::GenericObject, converting
+    assert_equal "world", converting.hello
+
+    json = JSON::GenericObject.dump(JSON::GenericObject[:hello => 'world'])
+    assert_equal JSON(json), JSON('{"json_class":"JSON::GenericObject","hello":"world"}')
+  end
+
+  private
+
+  def switch_json_creatable
+    JSON::GenericObject.json_creatable = true
+    yield
+  ensure
+    JSON::GenericObject.json_creatable = false
+  end
+end