oj 3.9.1 → 3.16.11

data/test/test_fast.rb

@@ -1,470 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.dirname(__FILE__)
-
-require 'helper'
-
-class DocTest < Minitest::Test
-  def setup
-    @default_options = Oj.default_options
-    @json1 = %|{
-      "array": [
-        {
-          "num"   : 3,
-          "string": "message",
-          "hash"  : {
-            "h2"  : {
-              "a" : [ 1, 2, 3 ]
-            }
-          }
-        }
-      ],
-      "boolean" : true
-    }|
-  end
-
-  def teardown
-    Oj.default_options = @default_options
-  end
-
-  def test_nil
-    json = %{null}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(NilClass, doc.type)
-      assert_nil(doc.fetch())
-    end
-  end
-
-  def test_true
-    json = %{true}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(TrueClass, doc.type)
-      assert_equal(true, doc.fetch())
-    end
-  end
-
-  def test_false
-    json = %{false}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(FalseClass, doc.type)
-      assert_equal(false, doc.fetch())
-    end
-  end
-
-  def test_string
-    json = %{"a string"}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(String, doc.type)
-      assert_equal('a string', doc.fetch())
-    end
-  end
-
-  def test_encoding
-    json = %{"ぴーたー"}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(String, doc.type)
-      assert_equal("ぴーたー", doc.fetch())
-    end
-  end
-
-  def test_encoding_escaped
-    json = %{"\\u3074\\u30fc\\u305f\\u30fc"}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(String, doc.type)
-      assert_equal("ぴーたー", doc.fetch())
-    end
-  end
-
-  def test_fixnum
-    json = %{12345}
-    Oj::Doc.open(json) do |doc|
-      if '2.4.0' <= RUBY_VERSION
-        assert_equal(Integer, doc.type)
-      else
-        assert_equal(Fixnum, doc.type)
-      end
-      assert_equal(12345, doc.fetch())
-    end
-  end
-
-  def test_float
-    json = %{12345.6789}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(Float, doc.type)
-      assert_equal(12345.6789, doc.fetch())
-    end
-  end
-
-  def test_float_exp
-    json = %{12345.6789e7}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(Float, doc.type)
-      #assert_equal(12345.6789e7, doc.fetch())
-      assert_equal(12345.6789e7.to_i, doc.fetch().to_i)
-    end
-  end
-
-  def test_array_empty
-    json = %{[]}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(Array, doc.type)
-      assert_equal([], doc.fetch())
-    end
-  end
-
-  def test_array
-    json = %{[true,false]}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(Array, doc.type)
-      assert_equal([true, false], doc.fetch())
-    end
-  end
-
-  def test_hash_empty
-    json = %{{}}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(Hash, doc.type)
-      assert_equal({}, doc.fetch())
-    end
-  end
-
-  def test_hash
-    json = %{{"one":true,"two":false}}
-    Oj::Doc.open(json) do |doc|
-      assert_equal(Hash, doc.type)
-      assert_equal({'one' => true, 'two' => false}, doc.fetch())
-    end
-  end
-
-  # move() and where?()
-  def test_move_hash
-    json = %{{"one":{"two":false}}}
-    Oj::Doc.open(json) do |doc|
-      doc.move('/one')
-      assert_equal('/one', doc.where?)
-      doc.move('/one/two')
-      assert_equal('/one/two', doc.where?)
-    end
-  end
-
-  def test_move_array
-    json = %{[1,[2,true]]}
-    Oj::Doc.open(json) do |doc|
-      doc.move('/1')
-      assert_equal('/1', doc.where?)
-      doc.move('/2/1')
-      assert_equal('/2/1', doc.where?)
-    end
-  end
-
-  def test_move
-    Oj::Doc.open(@json1) do |doc|
-      [ '/',
-        '/array',
-        '/boolean',
-        '/array/1/hash/h2/a/3',
-      ].each do |p|
-        doc.move(p)
-        assert_equal(p, doc.where?)
-      end
-      begin
-        doc.move('/array/x')
-      rescue Exception
-        assert_equal('/', doc.where?)
-        assert(true)
-      end
-    end
-  end
-
-  def test_move_slash
-    Oj::Doc.open(%|{"top":{"a/b":3}}|) do |doc|
-      doc.move('top/a\/b')
-      assert_equal('/top/a\/b', doc.where?)
-    end
-  end
-
-  def test_fetch_slash
-    Oj::Doc.open(%|{"a/b":3}|) do |doc|
-      x = doc.fetch('a\/b')
-      assert_equal(3, x)
-    end
-  end
-
-  def test_move_relative
-    Oj::Doc.open(@json1) do |doc|
-      [['/', 'array', '/array'],
-       ['/array', '1/num', '/array/1/num'],
-       ['/array/1/hash', 'h2/a', '/array/1/hash/h2/a'],
-       ['/array/1', 'hash/h2/a/2', '/array/1/hash/h2/a/2'],
-       ['/array/1/hash', '../string', '/array/1/string'],
-       ['/array/1/hash', '..', '/array/1'],
-      ].each do |start,path,where|
-        doc.move(start)
-        doc.move(path)
-        assert_equal(where, doc.where?)
-      end
-    end
-  end
-
-  def test_type
-    if '2.4.0' <= RUBY_VERSION
-      num_class = Integer
-    else
-      num_class = Fixnum
-    end
-    Oj::Doc.open(@json1) do |doc|
-      [['/', Hash],
-       ['/array', Array],
-       ['/array/1', Hash],
-       ['/array/1/num', num_class],
-       ['/array/1/string', String],
-       ['/array/1/hash/h2/a', Array],
-       ['/array/1/hash/../num', num_class],
-       ['/array/1/hash/../..', Array],
-      ].each do |path,type|
-        assert_equal(type, doc.type(path))
-      end
-    end
-  end
-
-  def test_local_key
-    Oj::Doc.open(@json1) do |doc|
-      [['/', nil],
-       ['/array', 'array'],
-       ['/array/1', 1],
-       ['/array/1/num', 'num'],
-       ['/array/1/string', 'string'],
-       ['/array/1/hash/h2/a', 'a'],
-       ['/array/1/hash/../num', 'num'],
-       ['/array/1/hash/..', 1],
-       ['/array/1/hash/../..', 'array'],
-      ].each do |path,key|
-        doc.move(path)
-        if key.nil?
-          assert_nil(doc.local_key())
-        else
-          assert_equal(key, doc.local_key())
-        end
-      end
-    end
-  end
-
-  def test_fetch_move
-    Oj::Doc.open(@json1) do |doc|
-      [['/array/1/num', 3],
-       ['/array/1/string', 'message'],
-       ['/array/1/hash/h2/a', [1, 2, 3]],
-       ['/array/1/hash/../num', 3],
-       ['/array/1/hash/..', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
-       ['/array/1/hash/../..', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
-       ['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
-       ['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
-       ['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
-      ].each do |path,val|
-        doc.move(path)
-        assert_equal(val, doc.fetch())
-      end
-    end
-  end
-
-  def test_fetch_path
-    Oj::Doc.open(@json1) do |doc|
-      [['/array/1/num', 3],
-       ['/array/1/string', 'message'],
-       ['/array/1/hash/h2/a', [1, 2, 3]],
-       ['/array/1/hash/../num', 3],
-       ['/array/1/hash/..', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
-       ['/array/1/hash/../..', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
-       ['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
-       ['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
-       ['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
-      ].each do |path,val|
-        assert_equal(val, doc.fetch(path))
-      end
-    end
-  end
-
-  def test_move_fetch_path
-    Oj::Doc.open(@json1) do |doc|
-      [['/array/1', 'num', 3],
-       ['/array/1', 'string', 'message'],
-       ['/array/1/hash', 'h2/a', [1, 2, 3]],
-      ].each do |path,fetch_path,val|
-        doc.move(path)
-        assert_equal(val, doc.fetch(fetch_path))
-      end
-    end
-  end
-
-  def test_home
-    Oj::Doc.open(@json1) do |doc|
-      doc.move('/array/1/num')
-      doc.home()
-      assert_equal('/', doc.where?)
-    end
-  end
-
-  def test_each_value_root
-    Oj::Doc.open(@json1) do |doc|
-      values = []
-      doc.each_value() { |v| values << v.to_s }
-      assert_equal(['1', '2', '3', '3', 'message', 'true'], values.sort)
-    end
-  end
-
-  def test_each_value_move
-    Oj::Doc.open(@json1) do |doc|
-      doc.move('/array/1/hash')
-      values = []
-      doc.each_value() { |v| values << v.to_s }
-      assert_equal(['1', '2', '3'], values.sort)
-    end
-  end
-
-  def test_each_value_path
-    Oj::Doc.open(@json1) do |doc|
-      values = []
-      doc.each_value('/array/1/hash') { |v| values << v.to_s }
-      assert_equal(['1', '2', '3'], values.sort)
-    end
-  end
-
-  def test_each_child_move
-    Oj::Doc.open(@json1) do |doc|
-      locations = []
-      doc.move('/array/1/hash/h2/a')
-      doc.each_child() { |d| locations << d.where? }
-      assert_equal(['/array/1/hash/h2/a/1', '/array/1/hash/h2/a/2', '/array/1/hash/h2/a/3'], locations)
-      locations = []
-      doc.move('/array/1')
-      doc.each_child() { |d| locations << d.where? }
-      assert_equal(['/array/1/num', '/array/1/string', '/array/1/hash'], locations)
-    end
-  end
-
-  def test_each_child_path
-    Oj::Doc.open(@json1) do |doc|
-      locations = []
-      doc.each_child('/array/1/hash/h2/a') { |d| locations << d.where? }
-      assert_equal(['/array/1/hash/h2/a/1', '/array/1/hash/h2/a/2', '/array/1/hash/h2/a/3'], locations)
-      locations = []
-      doc.each_child('/array/1') { |d| locations << d.where? }
-      assert_equal(['/array/1/num', '/array/1/string', '/array/1/hash'], locations)
-    end
-  end
-
-  def test_size
-    Oj::Doc.open('[1,2,3]') do |doc|
-      assert_equal(4, doc.size)
-    end
-    Oj::Doc.open('{"a":[1,2,3]}') do |doc|
-      assert_equal(5, doc.size)
-    end
-  end
-
-  def test_open_file
-    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
-    File.open(filename, 'w') { |f| f.write('{"a":[1,2,3]}') }
-    Oj::Doc.open_file(filename) do |doc|
-      assert_equal(5, doc.size)
-    end
-  end
-
-  def test_open_close
-    json = %{{"a":[1,2,3]}}
-    doc = Oj::Doc.open(json)
-    assert_equal(Oj::Doc, doc.class)
-    assert_equal(5, doc.size)
-    assert_equal('/', doc.where?)
-    doc.move('a/1')
-    doc.home()
-    assert_equal(2, doc.fetch('/a/2'))
-    assert_equal(2, doc.fetch('a/2'))
-    doc.close()
-    begin
-      doc.home()
-    rescue Exception
-      assert(true)
-    end
-  end
-
-  def test_file_open_close
-    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
-    File.open(filename, 'w') { |f| f.write('{"a":[1,2,3]}') }
-    doc = Oj::Doc.open_file(filename)
-    assert_equal(Oj::Doc, doc.class)
-    assert_equal(5, doc.size)
-    assert_equal('/', doc.where?)
-    doc.move('a/1')
-    doc.home()
-    assert_equal(2, doc.fetch('/a/2'))
-    assert_equal(2, doc.fetch('a/2'))
-    doc.close()
-    begin
-      doc.home()
-    rescue Exception
-      assert(true)
-    end
-  end
-
-  def test_open_no_close
-    json = %{{"a":[1,2,3]}}
-    doc = Oj::Doc.open(json)
-    assert_equal(Oj::Doc, doc.class)
-    assert_equal(5, doc.size)
-    assert_equal('/', doc.where?)
-    doc.move('a/1')
-    doc.home()
-    assert_equal(2, doc.fetch('/a/2'))
-    assert_equal(2, doc.fetch('a/2'))
-    doc = nil
-    GC.start
-    # a print statement confirms close is called
-  end
-
-  def test_dump
-    Oj::Doc.open('[1,[2,3]]') do |doc|
-      assert_equal('[1,[2,3]]', doc.dump())
-    end
-    Oj::Doc.open('[1,[2,3]]') do |doc|
-      assert_equal('[2,3]', doc.dump('/2'))
-    end
-  end
-
-  def test_each_leaf
-    results = Oj::Doc.open('[1,[2,3]]') do |doc|
-      h = {}
-      doc.each_leaf() { |d| h[d.where?] = d.fetch() }
-      h
-    end
-    assert_equal({'/1' => 1, '/2/1' => 2, '/2/2' => 3}, results)
-  end
-
-  def test_each_leaf_hash
-    results = Oj::Doc.open('{"a":{"x":2},"b":{"y":4}}') do |doc|
-      h = {}
-      doc.each_leaf() { |d| h[d.where?] = d.fetch() }
-      h
-    end
-    assert_equal({'/a/x' => 2, '/b/y' => 4}, results)
-  end
-
-  def test_comment
-    json = %{{
-  "x"/*one*/:/*two*/true,//three
-  "y":58/*four*/,
-  "z": [1,2/*five*/,
-3 // six
-]
-}
-}
-    results = Oj::Doc.open(json) do |doc|
-      h = {}
-      doc.each_leaf() { |d| h[d.where?] = d.fetch() }
-      h
-    end
-    assert_equal({'/x' => true, '/y' => 58, '/z/1' => 1, '/z/2' => 2, '/z/3' => 3}, results)
-  end
-
-end # DocTest

data/test/test_file.rb

@@ -1,239 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.dirname(__FILE__)
-
-require 'helper'
-
-class FileJuice < Minitest::Test
-  class Jam
-    attr_accessor :x, :y
-
-    def initialize(x, y)
-      @x = x
-      @y = y
-    end
-
-    def eql?(o)
-      self.class == o.class && @x == o.x && @y == o.y
-    end
-    alias == eql?
-
-  end# Jam
-
-  class Jeez < Jam
-    def initialize(x, y)
-      super
-    end
-
-    def to_json()
-      %{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
-    end
-
-    def self.json_create(h)
-      self.new(h['x'], h['y'])
-    end
-  end# Jeez
-
-  class Orange < Jam
-    def initialize(x, y)
-      super
-    end
-
-    def as_json()
-      { :json_class => self.class,
-        :x => @x,
-        :y => @y }
-    end
-
-    def self.json_create(h)
-      self.new(h['x'], h['y'])
-    end
-  end
-
-  def setup
-    @default_options = Oj.default_options
-  end
-
-  def teardown
-    Oj.default_options = @default_options
-  end
-
-  def test_nil
-    dump_and_load(nil, false)
-  end
-
-  def test_true
-    dump_and_load(true, false)
-  end
-
-  def test_false
-    dump_and_load(false, false)
-  end
-
-  def test_fixnum
-    dump_and_load(0, false)
-    dump_and_load(12345, false)
-    dump_and_load(-54321, false)
-    dump_and_load(1, false)
-  end
-
-  def test_float
-    mode = Oj.default_options()[:mode]
-    Oj.default_options = {:mode => :object}
-    dump_and_load(0.0, false)
-    dump_and_load(12345.6789, false)
-    dump_and_load(70.35, false)
-    dump_and_load(-54321.012, false)
-    dump_and_load(1.7775, false)
-    dump_and_load(2.5024, false)
-    dump_and_load(2.48e16, false)
-    dump_and_load(2.48e100 * 1.0e10, false)
-    dump_and_load(-2.48e100 * 1.0e10, false)
-    dump_and_load(1/0.0, false)
-    Oj.default_options = {:mode => mode}
-  end
-
-  def test_string
-    dump_and_load('', false)
-    dump_and_load('abc', false)
-    dump_and_load("abc\ndef", false)
-    dump_and_load("a\u0041", false)
-    assert_equal("a\u0000a", dump_and_load("a\u0000a", false))
-  end
-
-  def test_string_object
-    dump_and_load('abc', false)
-    dump_and_load(':abc', false)
-  end
-
-  def test_array
-    dump_and_load([], false)
-    dump_and_load([true, false], false)
-    dump_and_load(['a', 1, nil], false)
-    dump_and_load([[nil]], false)
-    dump_and_load([[nil], 58], false)
-  end
-
-  # Symbol
-  def test_symbol_object
-    Oj.default_options = { :mode => :object }
-    #dump_and_load(''.to_sym, false)
-    dump_and_load(:abc, false)
-    dump_and_load(':xyz'.to_sym, false)
-  end
-
-  # Time
-  def test_time_object
-    t = Time.now()
-    Oj.default_options = { :mode => :object, :time_format => :unix_zone }
-    dump_and_load(t, false)
-  end
-  def test_time_object_early
-    # Windows does not support dates before 1970.
-    return if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
-    t = Time.xmlschema("1954-01-05T00:00:00.123456")
-    Oj.default_options = { :mode => :object, :time_format => :unix_zone }
-    dump_and_load(t, false)
-  end
-
-  # Hash
-  def test_hash
-    Oj.default_options = { :mode => :strict }
-    dump_and_load({}, false)
-    dump_and_load({ 'true' => true, 'false' => false}, false)
-    dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
-  end
-
-  # Object with to_json()
-  def test_json_object_compat
-    Oj.default_options = { :mode => :compat, :use_to_json => true, :create_additions => true }
-    obj = Jeez.new(true, 58)
-    json = Oj.dump(obj, :indent => 2)
-    assert(%{{"json_class":"FileJuice::Jeez","x":true,"y":58}
-} == json ||
-           %{{"json_class":"FileJuice::Jeez","y":58,"x":true}
-} == json)
-    dump_and_load(obj, false)
-    Oj.default_options = { :mode => :compat, :use_to_json => false }
-  end
-
-  # Range
-  def test_range_object
-    Oj.default_options = { :mode => :object }
-    json = Oj.dump(1..7, :mode => :object, :indent => 0)
-    if 'rubinius' == $ruby
-      assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
-    elsif 'jruby' == $ruby
-      assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
-    else
-      assert_equal(%{{"^u":["Range",1,7,false]}}, json)
-    end
-    dump_and_load(1..7, false)
-    dump_and_load(1..1, false)
-    dump_and_load(1...7, false)
-  end
-
-  # BigNum
-  def test_bignum_object
-    Oj.default_options = { :mode => :compat }
-    dump_and_load(7 ** 55, false)
-  end
-
-  # BigDecimal
-  def test_bigdecimal_strict
-    mode = Oj.default_options[:mode]
-    Oj.default_options = {:mode => :strict}
-    dump_and_load(BigDecimal('3.14159265358979323846'), false)
-    Oj.default_options = {:mode => mode}
-  end
-
-  def test_bigdecimal_null
-    mode = Oj.default_options[:mode]
-    Oj.default_options = {:mode => :null}
-    dump_and_load(BigDecimal('3.14159265358979323846'), false)
-    Oj.default_options = {:mode => mode}
-  end
-
-  def test_bigdecimal_object
-    Oj.default_options = {:mode => :object}
-    dump_and_load(BigDecimal('3.14159265358979323846'), false)
-  end
-
-  # Date
-  def test_date_object
-    Oj.default_options = { :mode => :object }
-    dump_and_load(Date.new(2012, 6, 19), false)
-  end
-
-  # DateTime
-  def test_datetime_object
-    Oj.default_options = { :mode => :object }
-    dump_and_load(DateTime.new(2012, 6, 19), false)
-  end
-
-  def dump_and_load(obj, trace=false)
-    filename = File.join(File.dirname(__FILE__), 'file_test.json')
-    File.open(filename, "w") { |f|
-      Oj.to_stream(f, obj, :indent => 2)
-    }
-    puts "\n*** file: '#{File.read(filename)}'" if trace
-    loaded = Oj.load_file(filename)
-    if obj.is_a?(Time) && loaded.is_a?(Time)
-      assert_equal(obj.tv_sec, loaded.tv_sec)
-      if obj.respond_to?(:tv_nsec)
-        assert_equal(obj.tv_nsec, loaded.tv_nsec)
-      else
-        assert_equal(obj.tv_usec, loaded.tv_usec)
-      end
-      assert_equal(obj.utc?, loaded.utc?)
-      assert_equal(obj.utc_offset, loaded.utc_offset)
-    elsif obj.nil?
-      assert_nil(loaded)
-    else
-      assert_equal(obj, loaded)
-    end
-    loaded
-  end
-
-end