scout 5.7.3.pre.2 → 5.7.4

data/vendor/json_pure/tests/test_json_addition.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+# -*- coding:utf-8 -*-
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'setup_variant')
+require 'json/add/core'
+require 'json/add/complex'
+require 'json/add/rational'
+require 'json/add/bigdecimal'
+require 'json/add/ostruct'
+require 'date'
+
+class TestJSONAddition < Test::Unit::TestCase
+  include JSON
+
+  class A
+    def initialize(a)
+      @a = a
+    end
+
+    attr_reader :a
+
+    def ==(other)
+      a == other.a
+    end
+
+    def self.json_create(object)
+      new(*object['args'])
+    end
+
+    def to_json(*args)
+      {
+        'json_class'  => self.class.name,
+        'args'        => [ @a ],
+      }.to_json(*args)
+    end
+  end
+
+  class A2 < A
+    def to_json(*args)
+      {
+        'json_class'  => self.class.name,
+        'args'        => [ @a ],
+      }.to_json(*args)
+    end
+  end
+
+  class B
+    def self.json_creatable?
+      false
+    end
+
+    def to_json(*args)
+      {
+        'json_class'  => self.class.name,
+      }.to_json(*args)
+    end
+  end
+
+  class C
+    def self.json_creatable?
+      false
+    end
+
+    def to_json(*args)
+      {
+        'json_class'  => 'TestJSONAddition::Nix',
+      }.to_json(*args)
+    end
+  end
+
+  def test_extended_json
+    a = A.new(666)
+    assert A.json_creatable?
+    json = generate(a)
+    a_again = JSON.parse(json, :create_additions => true)
+    assert_kind_of a.class, a_again
+    assert_equal a, a_again
+  end
+
+  def test_extended_json_default
+    a = A.new(666)
+    assert A.json_creatable?
+    json = generate(a)
+    a_hash = JSON.parse(json)
+    assert_kind_of Hash, a_hash
+  end
+
+  def test_extended_json_disabled
+    a = A.new(666)
+    assert A.json_creatable?
+    json = generate(a)
+    a_again = JSON.parse(json, :create_additions => true)
+    assert_kind_of a.class, a_again
+    assert_equal a, a_again
+    a_hash = JSON.parse(json, :create_additions => false)
+    assert_kind_of Hash, a_hash
+    assert_equal(
+      {"args"=>[666], "json_class"=>"TestJSONAddition::A"}.sort_by { |k,| k },
+      a_hash.sort_by { |k,| k }
+    )
+  end
+
+  def test_extended_json_fail1
+    b = B.new
+    assert !B.json_creatable?
+    json = generate(b)
+    assert_equal({ "json_class"=>"TestJSONAddition::B" }, JSON.parse(json))
+  end
+
+  def test_extended_json_fail2
+    c = C.new
+    assert !C.json_creatable?
+    json = generate(c)
+    assert_raises(ArgumentError, NameError) { JSON.parse(json, :create_additions => true) }
+  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
+      raw_array << i
+    end
+    json = raw.to_json_raw
+    json_raw_object = raw.to_json_raw_object
+    hash = { 'json_class' => 'String', 'raw'=> raw_array }
+    assert_equal hash, json_raw_object
+    assert_match(/\A\{.*\}\z/, json)
+    assert_match(/"json_class":"String"/, json)
+    assert_match(/"raw":\[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255\]/, json)
+    raw_again = JSON.parse(json, :create_additions => true)
+    assert_equal raw, raw_again
+  end
+
+  MyJsonStruct = Struct.new 'MyJsonStruct', :foo, :bar
+
+  def test_core
+    t = Time.now
+    assert_equal t, JSON(JSON(t), :create_additions => true)
+    d = Date.today
+    assert_equal d, JSON(JSON(d), :create_additions => true)
+    d = DateTime.civil(2007, 6, 14, 14, 57, 10, Rational(1, 12), 2299161)
+    assert_equal d, JSON(JSON(d), :create_additions => true)
+    assert_equal 1..10, JSON(JSON(1..10), :create_additions => true)
+    assert_equal 1...10, JSON(JSON(1...10), :create_additions => true)
+    assert_equal "a".."c", JSON(JSON("a".."c"), :create_additions => true)
+    assert_equal "a"..."c", JSON(JSON("a"..."c"), :create_additions => true)
+    s = MyJsonStruct.new 4711, 'foot'
+    assert_equal s, JSON(JSON(s), :create_additions => true)
+    struct = Struct.new :foo, :bar
+    s = struct.new 4711, 'foot'
+    assert_raises(JSONError) { JSON(s) }
+    begin
+      raise TypeError, "test me"
+    rescue TypeError => e
+      e_json = JSON.generate e
+      e_again = JSON e_json, :create_additions => true
+      assert_kind_of TypeError, e_again
+      assert_equal e.message, e_again.message
+      assert_equal e.backtrace, e_again.backtrace
+    end
+    assert_equal(/foo/, JSON(JSON(/foo/), :create_additions => true))
+    assert_equal(/foo/i, JSON(JSON(/foo/i), :create_additions => true))
+  end
+
+  def test_utc_datetime
+    now = Time.now
+    d = DateTime.parse(now.to_s, :create_additions => true)                    # usual case
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+    d = DateTime.parse(now.utc.to_s)                # of = 0
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(1,24))
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(12,24))
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+  end
+
+  def test_rational_complex
+    assert_equal Rational(2, 9), JSON.parse(JSON(Rational(2, 9)), :create_additions => true)
+    assert_equal Complex(2, 9), JSON.parse(JSON(Complex(2, 9)), :create_additions => true)
+  end
+
+  def test_bigdecimal
+    assert_equal BigDecimal('3.141', 23), JSON(JSON(BigDecimal('3.141', 23)), :create_additions => true)
+    assert_equal BigDecimal('3.141', 666), JSON(JSON(BigDecimal('3.141', 666)), :create_additions => true)
+  end
+
+  def test_ostruct
+    o = OpenStruct.new
+    # XXX this won't work; o.foo = { :bar => true }
+    o.foo = { 'bar' => true }
+    assert_equal o, JSON.parse(JSON(o), :create_additions => true)
+  end
+end

data/vendor/json_pure/tests/test_json_encoding.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'setup_variant')
+
+class TestJSONEncoding < Test::Unit::TestCase
+  include JSON
+
+  def setup
+    @utf_8 = '["© ≠ €!"]'
+    @parsed = [ "© ≠ €!" ]
+    @generated = '["\u00a9 \u2260 \u20ac!"]'
+    if String.method_defined?(:encode)
+      @utf_16_data = [@parsed.first.encode('utf-16be', 'utf-8')]
+      @utf_8_ascii_8bit = @utf_8.dup.force_encoding(Encoding::ASCII_8BIT)
+      @utf_16be = @utf_8.encode('utf-16be', 'utf-8')
+      @utf_16be_ascii_8bit = @utf_16be.dup.force_encoding(Encoding::ASCII_8BIT)
+      @utf_16le = @utf_8.encode('utf-16le', 'utf-8')
+      @utf_16le_ascii_8bit = @utf_16le.dup.force_encoding(Encoding::ASCII_8BIT)
+      @utf_32be = @utf_8.encode('utf-32be', 'utf-8')
+      @utf_32be_ascii_8bit = @utf_32be.dup.force_encoding(Encoding::ASCII_8BIT)
+      @utf_32le = @utf_8.encode('utf-32le', 'utf-8')
+      @utf_32le_ascii_8bit = @utf_32le.dup.force_encoding(Encoding::ASCII_8BIT)
+    else
+      require 'iconv'
+      @utf_16_data = Iconv.iconv('utf-16be', 'utf-8', @parsed.first)
+      @utf_8_ascii_8bit = @utf_8.dup
+      @utf_16be, = Iconv.iconv('utf-16be', 'utf-8', @utf_8)
+      @utf_16be_ascii_8bit = @utf_16be.dup
+      @utf_16le, = Iconv.iconv('utf-16le', 'utf-8', @utf_8)
+      @utf_16le_ascii_8bit = @utf_16le.dup
+      @utf_32be, = Iconv.iconv('utf-32be', 'utf-8', @utf_8)
+      @utf_32be_ascii_8bit = @utf_32be.dup
+      @utf_32le, = Iconv.iconv('utf-32le', 'utf-8', @utf_8)
+      @utf_32le_ascii_8bit = @utf_32le.dup
+    end
+  end
+
+  def test_parse
+    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_parse_ascii_8bit
+    assert_equal @parsed, JSON.parse(@utf_8_ascii_8bit)
+    assert_equal @parsed, JSON.parse(@utf_16be_ascii_8bit)
+    assert_equal @parsed, JSON.parse(@utf_16le_ascii_8bit)
+    assert_equal @parsed, JSON.parse(@utf_32be_ascii_8bit)
+    assert_equal @parsed, JSON.parse(@utf_32le_ascii_8bit)
+  end
+
+  def test_generate
+    assert_equal @generated, JSON.generate(@parsed, :ascii_only => true)
+    if defined?(::Encoding)
+      assert_equal @generated, JSON.generate(@utf_16_data, :ascii_only => true)
+    else
+      # XXX checking of correct utf8 data is not as strict (yet?) without :ascii_only
+      assert_raises(JSON::GeneratorError) { JSON.generate(@utf_16_data, :ascii_only => true) }
+    end
+  end
+end

data/vendor/json_pure/tests/test_json_fixtures.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'setup_variant')
+
+class TestJSONFixtures < Test::Unit::TestCase
+  def setup
+    fixtures = File.join(File.dirname(__FILE__), 'fixtures/*.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_raises(JSON::ParserError, JSON::NestingError,
+        "Did not fail for fixture '#{name}': #{source.inspect}") do
+        JSON.parse(source)
+      end
+    end
+  end
+end

data/vendor/json_pure/tests/test_json_generate.rb

@@ -0,0 +1,322 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'setup_variant')
+
+class TestJSONGenerate < 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
+    }
+    @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 = generate(@hash)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    json = JSON[@hash]
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    parsed_json = parse(json)
+    assert_equal(@hash, parsed_json)
+    json = generate({1=>2})
+    assert_equal('{"1":2}', json)
+    parsed_json = parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_raise(GeneratorError) { generate(666) }
+    assert_equal '666', generate(666, :quirks_mode => true)
+  end
+
+  def test_generate_pretty
+    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 = parse(json)
+    assert_equal(@hash, parsed_json)
+    json = pretty_generate({1=>2})
+    assert_equal(<<'EOT'.chomp, json)
+{
+  "1": 2
+}
+EOT
+    parsed_json = parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_raise(GeneratorError) { pretty_generate(666) }
+    assert_equal '666', pretty_generate(666, :quirks_mode => true)
+  end
+
+  def test_fast_generate
+    json = fast_generate(@hash)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    parsed_json = parse(json)
+    assert_equal(@hash, parsed_json)
+    json = fast_generate({1=>2})
+    assert_equal('{"1":2}', json)
+    parsed_json = parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_raise(GeneratorError) { fast_generate(666) }
+    assert_equal '666', fast_generate(666, :quirks_mode => true)
+  end
+
+  def test_own_state
+    state = State.new
+    json = generate(@hash, state)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
+    parsed_json = parse(json)
+    assert_equal(@hash, parsed_json)
+    json = generate({1=>2}, state)
+    assert_equal('{"1":2}', json)
+    parsed_json = parse(json)
+    assert_equal({"1"=>2}, parsed_json)
+    assert_raise(GeneratorError) { generate(666, state) }
+    state.quirks_mode = true
+    assert state.quirks_mode?
+    assert_equal '666', generate(666, state)
+  end
+
+  def test_states
+    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_raises(JSON::NestingError) {  generate(h) }
+    assert_raises(JSON::NestingError) {  generate(h, s) }
+    s = JSON.state.new
+    a = [ 1, 2 ]
+    a << a
+    assert_raises(JSON::NestingError) {  generate(a, s) }
+    assert s.check_circular?
+    assert s[:check_circular?]
+  end
+
+  def test_pretty_state
+    state = PRETTY_STATE_PROTOTYPE.dup
+    assert_equal({
+      :allow_nan             => false,
+      :array_nl              => "\n",
+      :ascii_only            => false,
+      :buffer_initial_length => 1024,
+      :quirks_mode           => false,
+      :depth                 => 0,
+      :indent                => "  ",
+      :max_nesting           => 100,
+      :object_nl             => "\n",
+      :space                 => " ",
+      :space_before          => "",
+    }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
+  end
+
+  def test_safe_state
+    state = SAFE_STATE_PROTOTYPE.dup
+    assert_equal({
+      :allow_nan             => false,
+      :array_nl              => "",
+      :ascii_only            => false,
+      :buffer_initial_length => 1024,
+      :quirks_mode           => false,
+      :depth                 => 0,
+      :indent                => "",
+      :max_nesting           => 100,
+      :object_nl             => "",
+      :space                 => "",
+      :space_before          => "",
+    }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
+  end
+
+  def test_fast_state
+    state = FAST_STATE_PROTOTYPE.dup
+    assert_equal({
+      :allow_nan             => false,
+      :array_nl              => "",
+      :ascii_only            => false,
+      :buffer_initial_length => 1024,
+      :quirks_mode           => false,
+      :depth                 => 0,
+      :indent                => "",
+      :max_nesting           => 0,
+      :object_nl             => "",
+      :space                 => "",
+      :space_before          => "",
+    }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s })
+  end
+
+  def test_allow_nan
+    assert_raises(GeneratorError) { generate([JSON::NaN]) }
+    assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
+    assert_raises(GeneratorError) { fast_generate([JSON::NaN]) }
+    assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) }
+    assert_equal "[\n  NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
+    assert_raises(GeneratorError) { generate([JSON::Infinity]) }
+    assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
+    assert_raises(GeneratorError) { fast_generate([JSON::Infinity]) }
+    assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) }
+    assert_equal "[\n  Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
+    assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) }
+    assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
+    assert_raises(GeneratorError) { fast_generate([JSON::MinusInfinity]) }
+    assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
+    assert_equal "[\n  -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
+  end
+
+  def test_depth
+    ary = []; ary << ary
+    assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
+    assert_raises(JSON::NestingError) { JSON.generate(ary) }
+    assert_equal 0, JSON::SAFE_STATE_PROTOTYPE.depth
+    assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
+    assert_raises(JSON::NestingError) { JSON.pretty_generate(ary) }
+    assert_equal 0, JSON::PRETTY_STATE_PROTOTYPE.depth
+    s = JSON.state.new
+    assert_equal 0, s.depth
+    assert_raises(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
+    bignum_too_long_to_embed_as_string = 1234567890123456789012345
+    expect = bignum_too_long_to_embed_as_string.to_s
+    stress, GC.stress = GC.stress, true
+
+    10.times do |i|
+      tmp = bignum_too_long_to_embed_as_string.to_json
+      assert_equal expect, tmp
+    end
+  ensure
+    GC.stress = stress
+  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
+        Bignum.class_eval do
+          def to_s
+          end
+        end
+        begin
+          JSON::Ext::Generator::State.new.generate(1<<64)
+          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
+end