json 2.5.1-java → 2.6.2-java

data/tests/json_common_interface_test.rb

@@ -1,169 +0,0 @@
-#frozen_string_literal: false
-require 'test_helper'
-require 'stringio'
-require 'tempfile'
-
-class JSONCommonInterfaceTest < Test::Unit::TestCase
-  include JSON
-
-  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
-    }
-    @json = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
-      '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
-  end
-
-  def test_index
-    assert_equal @json, JSON[@hash]
-    assert_equal @hash, JSON[@json]
-  end
-
-  def test_parser
-    assert_match(/::Parser\z/, JSON.parser.name)
-  end
-
-  def test_generator
-    assert_match(/::Generator\z/, JSON.generator.name)
-  end
-
-  def test_state
-    assert_match(/::Generator::State\z/, JSON.state.name)
-  end
-
-  def test_create_id
-    assert_equal 'json_class', JSON.create_id
-    JSON.create_id = 'foo_bar'
-    assert_equal 'foo_bar', JSON.create_id
-  ensure
-    JSON.create_id = 'json_class'
-  end
-
-  def test_deep_const_get
-    assert_raise(ArgumentError) { JSON.deep_const_get('Nix::Da') }
-    assert_equal File::SEPARATOR, JSON.deep_const_get('File::SEPARATOR')
-  end
-
-  def test_parse
-    assert_equal [ 1, 2, 3, ], JSON.parse('[ 1, 2, 3 ]')
-  end
-
-  def test_parse_bang
-    assert_equal [ 1, Infinity, 3, ], JSON.parse!('[ 1, Infinity, 3 ]')
-  end
-
-  def test_generate
-    assert_equal '[1,2,3]', JSON.generate([ 1, 2, 3 ])
-  end
-
-  def test_fast_generate
-    assert_equal '[1,2,3]', JSON.generate([ 1, 2, 3 ])
-  end
-
-  def test_pretty_generate
-    assert_equal "[\n  1,\n  2,\n  3\n]", JSON.pretty_generate([ 1, 2, 3 ])
-  end
-
-  def test_load
-    assert_equal @hash, JSON.load(@json)
-    tempfile = Tempfile.open('@json')
-    tempfile.write @json
-    tempfile.rewind
-    assert_equal @hash, JSON.load(tempfile)
-    stringio = StringIO.new(@json)
-    stringio.rewind
-    assert_equal @hash, JSON.load(stringio)
-    assert_equal nil, JSON.load(nil)
-    assert_equal nil, JSON.load('')
-  ensure
-    tempfile.close!
-  end
-
-  def test_load_with_options
-    json  = '{ "foo": NaN }'
-    assert JSON.load(json, nil, :allow_nan => true)['foo'].nan?
-  end
-
-  def test_load_null
-    assert_equal nil, JSON.load(nil, nil, :allow_blank => true)
-    assert_raise(TypeError) { JSON.load(nil, nil, :allow_blank => false) }
-    assert_raise(JSON::ParserError) { JSON.load('', nil, :allow_blank => false) }
-  end
-
-  def test_dump
-    too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
-    assert_equal too_deep, dump(eval(too_deep))
-    assert_kind_of String, Marshal.dump(eval(too_deep))
-    assert_raise(ArgumentError) { dump(eval(too_deep), 100) }
-    assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
-    assert_equal too_deep, dump(eval(too_deep), 101)
-    assert_kind_of String, Marshal.dump(eval(too_deep), 101)
-    output = StringIO.new
-    dump(eval(too_deep), output)
-    assert_equal too_deep, output.string
-    output = StringIO.new
-    dump(eval(too_deep), output, 101)
-    assert_equal too_deep, output.string
-  end
-
-  def test_dump_should_modify_defaults
-    max_nesting = JSON.dump_default_options[:max_nesting]
-    dump([], StringIO.new, 10)
-    assert_equal max_nesting, JSON.dump_default_options[:max_nesting]
-  end
-
-  def test_JSON
-    assert_equal @json, JSON(@hash)
-    assert_equal @hash, JSON(@json)
-  end
-
-  def test_load_file
-    test_load_shared(:load_file)
-  end
-
-  def test_load_file!
-    test_load_shared(:load_file!)
-  end
-
-  def test_load_file_with_option
-    test_load_file_with_option_shared(:load_file)
-  end
-
-  def test_load_file_with_option!
-    test_load_file_with_option_shared(:load_file!)
-  end
-
-  private
-
-  def test_load_shared(method_name)
-    temp_file_containing(@json) do |filespec|
-      assert_equal JSON.public_send(method_name, filespec), @hash
-    end
-  end
-
-  def test_load_file_with_option_shared(method_name)
-    temp_file_containing(@json) do |filespec|
-      parsed_object = JSON.public_send(method_name, filespec, symbolize_names: true)
-      key_classes = parsed_object.keys.map(&:class)
-      assert_include(key_classes, Symbol)
-      assert_not_include(key_classes, String)
-    end
-  end
-
-  def temp_file_containing(text, file_prefix = '')
-    raise "This method must be called with a code block." unless block_given?
-
-    Tempfile.create(file_prefix) do |file|
-      file << text
-      file.close
-      yield file.path
-    end
-  end
-end

data/tests/json_encoding_test.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-#frozen_string_literal: false
-require 'test_helper'
-
-class JSONEncodingTest < Test::Unit::TestCase
-  include JSON
-
-  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, parse(json)
-    json = '["\u00a9 \u2260 \u20ac! \u0001"]'
-    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(: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(:ascii_only => true)
-    assert_equal utf8, parse(json)
-    assert_equal '["Ã"]', generate(["Ã"], :ascii_only => false)
-    assert_equal '["\\u00c3"]', generate(["Ã"], :ascii_only => true)
-    assert_equal ["€"], parse('["\u20ac"]')
-    utf8 = ["\xf0\xa0\x80\x81"]
-    json = "[\"\xf0\xa0\x80\x81\"]"
-    assert_equal json, generate(utf8, :ascii_only => false)
-    assert_equal utf8, parse(json)
-    json = '["\ud840\udc01"]'
-    assert_equal json, generate(utf8, :ascii_only => true)
-    assert_equal utf8, parse(json)
-    assert_raise(JSON::ParserError) { parse('"\u"') }
-    assert_raise(JSON::ParserError) { parse('"\ud800"') }
-  end
-
-  def test_chars
-    (0..0x7f).each do |i|
-      json = '["\u%04x"]' % i
-      if RUBY_VERSION >= "1.9."
-        i = i.chr
-      end
-      assert_equal i, parse(json).first[0]
-      if i == ?\b
-        generated = generate(["" << i])
-        assert '["\b"]' == generated || '["\10"]' == generated
-      elsif [?\n, ?\r, ?\t, ?\f].include?(i)
-        assert_equal '[' << ('' << i).dump << ']', generate(["" << i])
-      elsif i.chr < 0x20.chr
-        assert_equal json, generate(["" << i])
-      end
-    end
-    assert_raise(JSON::GeneratorError) do
-      generate(["\x80"], :ascii_only => true)
-    end
-    assert_equal "\302\200", parse('["\u0080"]').first
-  end
-end

data/tests/json_ext_parser_test.rb

@@ -1,15 +0,0 @@
-#frozen_string_literal: false
-require 'test_helper'
-
-class JSONExtParserTest < Test::Unit::TestCase
-  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/tests/json_fixtures_test.rb

@@ -1,40 +0,0 @@
-#frozen_string_literal: false
-require '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
-    verbose_bak, $VERBOSE = $VERBOSE, nil
-    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
-  ensure
-    $VERBOSE = verbose_bak
-  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
-
-  def test_sanity
-    assert(@passed.size > 5)
-    assert(@failed.size > 20)
-  end
-end