oj 3.7.4 → 3.13.23

data/test/test_gc.rb

@@ -26,10 +26,12 @@ class GCTest < Minitest::Test
 
   def setup
     @default_options = Oj.default_options
+    GC.stress = true
   end
 
   def teardown
     Oj.default_options = @default_options
+    GC.stress = false
   end
 
   # if no crash then the GC marking is working
@@ -46,4 +48,13 @@ class GCTest < Minitest::Test
     json = Oj.dump(g, :mode => :object)
     Oj.object_load(json)
   end
+
+  def test_parse_gc
+    json = '{"a":"Alpha","b":true,"c":12345,"d":[true,[false,[-123456789,null],3.9676,["Something else.",false],null]],"e":{"zero":null,"one":1,"two":2,"three":[3],"four":[0,1,2,3,4]},"f":null,"h":{"a":{"b":{"c":{"d":{"e":{"f":{"g":null}}}}}}},"i":[[[[[[[null]]]]]]]}'
+
+    50.times do
+      data = Oj.load(json)
+      assert_equal(json, Oj.dump(data))
+    end
+  end
 end

data/test/test_generate.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.dirname(__FILE__)
+$oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+%w(lib ext).each do |dir|
+  $: << File.join($oj_dir, dir)
+end
+
+require 'minitest'
+require 'minitest/autorun'
+require 'oj'
+
+class Generator < Minitest::Test
+
+  def test_before
+    json = Oj.generate({})
+    assert_equal("{}", json)
+  end
+
+end

data/test/test_hash.rb

@@ -5,7 +5,7 @@ $: << File.dirname(__FILE__)
 
 require 'helper'
 
-class Hashi < Minitest::Test
+class HashTest < Minitest::Test
 
   module TestModule
   end
@@ -25,5 +25,15 @@ class Hashi < Minitest::Test
     assert_equal(3, obj[:abc])
     assert_equal(3, obj.abc())
   end
+
+  def test_marshal
+    h = Oj::EasyHash.new()
+    h['abc'] = 3
+    out = Marshal.dump(h)
+
+    obj = Marshal.load(out)
+    assert_equal(Oj::EasyHash, obj.class)
+    assert_equal(3, obj[:abc])
+  end
   
 end # HashTest

data/test/test_integer_range.rb

@@ -15,7 +15,7 @@ class IntegerRangeTest < Minitest::Test
   def setup
     @default_options = Oj.default_options
     # in null mode other options other than the number formats are not used.
-    Oj.default_options = { :mode => :null }
+    Oj.default_options = { :mode => :null, bigdecimal_as_decimal: true }
   end
 
   def teardown
@@ -70,4 +70,3 @@ class IntegerRangeTest < Minitest::Test
     assert_equal(exp, Oj.dump(test, integer_range: false))
   end
 end
-

data/test/test_object.rb

@@ -7,11 +7,12 @@ require 'helper'
 
 class ObjectJuice < Minitest::Test
   class Jeez
-    attr_accessor :x, :y
+    attr_accessor :x, :y, :_z
 
     def initialize(x, y)
       @x = x
       @y = y
+      @_z = x.to_s
     end
 
     def eql?(o)
@@ -687,7 +688,7 @@ class ObjectJuice < Minitest::Test
 
   def test_json_object_object
     obj = Jeez.new(true, 58)
-    json = Oj.dump(obj, :mode => :object, :indent => 2)
+    json = Oj.dump(obj, mode: :object, indent: 2, ignore_under: true)
     assert(%{{
   "^o":"ObjectJuice::Jeez",
   "x":true,
@@ -793,13 +794,37 @@ class ObjectJuice < Minitest::Test
     end
   end
 
+  class SubX < Exception
+    def initialize
+      super("sub")
+      @xyz = 123
+    end
+  end
+
+  def test_exception_subclass
+    err = nil
+    begin
+      raise SubX.new
+    rescue Exception => e
+      err = e
+    end
+    json = Oj.dump(err, :mode => :object, :indent => 2)
+    #puts "*** #{json}"
+    e2 = Oj.load(json, :mode => :strict)
+    assert_equal(err.class.to_s, e2['^o'])
+    assert_equal(err.message, e2['~mesg'])
+    assert_equal(err.backtrace, e2['~bt'])
+    e2 = Oj.load(json, :mode => :object)
+    assert_equal(e, e2);
+  end
+
   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)
-    else
+    if 'ruby' == $ruby
       assert_equal(%{{"^u":["Range",1,7,false]}}, json)
+    else
+      assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
     end
     dump_and_load(1..7, false)
     dump_and_load(1..1, false)
@@ -844,6 +869,14 @@ class ObjectJuice < Minitest::Test
     assert_equal(a2[1].__id__, a2.__id__)
   end
 
+  def test_circular_array3
+    a = ['^r1']
+    json = Oj.dump(a, mode: :object, circular: true)
+    assert_equal(%{["^i1","\\u005er1"]}, json)
+    a2 = Oj.load(json, mode: :object, circular: true)
+    assert_equal(a, a2)
+  end
+
   def test_circular_hash2
     h = { 'a' => 7 }
     h['b'] = h
@@ -915,6 +948,11 @@ class ObjectJuice < Minitest::Test
 
   def test_odd_date
     dump_and_load(Date.new(2012, 6, 19), false)
+
+    Oj.register_odd(Date, Date, :jd, :jd)
+    json = Oj.dump(Date.new(2015, 3, 7), :mode => :object)
+    assert_equal(%|{"^O":"Date","jd":2457089}|, json)
+    dump_and_load(Date.new(2012, 6, 19), false)
   end
 
   def test_odd_datetime
@@ -939,13 +977,6 @@ class ObjectJuice < Minitest::Test
     dump_and_load(s, false)
   end
 
-  def test_odd_date_replaced
-    Oj.register_odd(Date, Date, :jd, :jd)
-    json = Oj.dump(Date.new(2015, 3, 7), :mode => :object)
-    assert_equal(%|{"^O":"Date","jd":2457089}|, json)
-    dump_and_load(Date.new(2012, 6, 19), false)
-  end
-
   def test_odd_raw
     Oj.register_odd_raw(Raw, Raw, :create, :to_json)
     json = Oj.dump(Raw.new(%|{"a":1}|), :mode => :object)

data/test/test_parser.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+$oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+%w(lib ext).each do |dir|
+  $: << File.join($oj_dir, dir)
+end
+
+require 'test_parser_usual'
+require 'test_parser_saj'

data/test/test_parser_debug.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.dirname(__FILE__)
+$oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+%w(lib ext).each do |dir|
+  $: << File.join($oj_dir, dir)
+end
+
+require 'minitest'
+require 'minitest/autorun'
+require 'stringio'
+require 'date'
+require 'bigdecimal'
+require 'oj'
+
+class ParserJuice < Minitest::Test
+
+  def test_array
+    p = Oj::Parser.new(:debug)
+    out = p.parse(%|[true, false, null, 123, -1.23, "abc"]|)
+    puts out
+    out = p.parse(%|{"abc": []}|)
+    puts out
+  end
+
+end

data/test/test_parser_saj.rb

@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+$json = %|{
+  "array": [
+    {
+      "num"   : 3,
+      "string": "message",
+      "hash"  : {
+        "h2"  : {
+          "a" : [ 1, 2, 3 ]
+        }
+      }
+    }
+  ],
+  "boolean" : true
+}|
+
+class AllSaj < Oj::Saj
+  attr_accessor :calls
+
+  def initialize()
+    @calls = []
+  end
+
+  def hash_start(key)
+    @calls << [:hash_start, key]
+  end
+
+  def hash_end(key)
+    @calls << [:hash_end, key]
+  end
+
+  def array_start(key)
+    @calls << [:array_start, key]
+  end
+
+  def array_end(key)
+    @calls << [:array_end, key]
+  end
+
+  def add_value(value, key)
+    @calls << [:add_value, value, key]
+  end
+
+  def error(message, line, column)
+    @calls << [:error, message, line, column]
+  end
+
+end # AllSaj
+
+class LocSaj
+  attr_accessor :calls
+
+  def initialize()
+    @calls = []
+  end
+
+  def hash_start(key, line, column)
+    @calls << [:hash_start, key, line, column]
+  end
+
+  def hash_end(key, line, column)
+    @calls << [:hash_end, key, line, column]
+  end
+
+  def array_start(key, line, column)
+    @calls << [:array_start, key, line, column]
+  end
+
+  def array_end(key, line, column)
+    @calls << [:array_end, key, line, column]
+  end
+
+  def add_value(value, key, line, column)
+    @calls << [:add_value, value, key, line, column]
+  end
+
+end # LocSaj
+
+class SajTest < Minitest::Test
+
+  def test_nil
+    handler = AllSaj.new()
+    json = %{null}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, nil, nil]], handler.calls)
+  end
+
+  def test_true
+    handler = AllSaj.new()
+    json = %{true}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, true, nil]], handler.calls)
+  end
+
+  def test_false
+    handler = AllSaj.new()
+    json = %{false}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, false, nil]], handler.calls)
+  end
+
+  def test_string
+    handler = AllSaj.new()
+    json = %{"a string"}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, 'a string', nil]], handler.calls)
+  end
+
+  def test_fixnum
+    handler = AllSaj.new()
+    json = %{12345}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, 12345, nil]], handler.calls)
+  end
+
+  def test_float
+    handler = AllSaj.new()
+    json = %{12345.6789}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, 12345.6789, nil]], handler.calls)
+  end
+
+  def test_float_exp
+    handler = AllSaj.new()
+    json = %{12345.6789e7}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal(1, handler.calls.size)
+    assert_equal(:add_value, handler.calls[0][0])
+    assert_equal((12345.6789e7 * 10000).to_i, (handler.calls[0][1] * 10000).to_i)
+  end
+
+  def test_bignum
+    handler = AllSaj.new()
+    json = %{-11.899999999999999}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal(1, handler.calls.size)
+    assert_equal(:add_value, handler.calls[0][0])
+    assert_equal(-118999, (handler.calls[0][1] * 10000).to_i)
+  end
+
+  def test_bignum_loc
+    handler = LocSaj.new()
+    json = <<~JSON
+      {
+        "width": 192.33800000000002,
+        "xaxis": {
+          "anchor": "y"
+        }
+      }
+    JSON
+
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal(6, handler.calls.size)
+    assert_equal(1_923_380, (handler.calls[1][1] * 10000).to_i)
+    handler.calls[1][1] = 1_923_380
+    assert_equal([[:hash_start, nil, 1, 1],
+                  [:add_value, 1923380, 'width', 2, 30],
+                  [:hash_start, 'xaxis', 3, 12],
+                  [:add_value, 'y', 'anchor', 4, 17],
+                  [:hash_end, 'xaxis', 5, 3],
+                  [:hash_end, nil, 6, 1]],
+                 handler.calls)
+  end
+
+  def test_array_empty
+    handler = AllSaj.new()
+    json = %{[]}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:array_start, nil],
+                  [:array_end, nil]], handler.calls)
+  end
+
+  def test_array
+    handler = AllSaj.new()
+    json = %{[true,false]}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:array_start, nil],
+                  [:add_value, true, nil],
+                  [:add_value, false, nil],
+                  [:array_end, nil]], handler.calls)
+  end
+
+  def test_hash_empty
+    handler = AllSaj.new()
+    json = %{{}}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:hash_start, nil],
+                  [:hash_end, nil]], handler.calls)
+  end
+
+  def test_hash
+    handler = AllSaj.new()
+    json = %{{"one":true,"two":false}}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:hash_start, nil],
+                  [:add_value, true, 'one'],
+                  [:add_value, false, 'two'],
+                  [:hash_end, nil]], handler.calls)
+  end
+
+  def test_full
+    handler = AllSaj.new()
+    Oj.saj_parse(handler, $json)
+    assert_equal([[:hash_start, nil],
+                  [:array_start, 'array'],
+                  [:hash_start, nil],
+                  [:add_value, 3, 'num'],
+                  [:add_value, 'message', 'string'],
+                  [:hash_start, 'hash'],
+                  [:hash_start, 'h2'],
+                  [:array_start, 'a'],
+                  [:add_value, 1, nil],
+                  [:add_value, 2, nil],
+                  [:add_value, 3, nil],
+                  [:array_end, 'a'],
+                  [:hash_end, 'h2'],
+                  [:hash_end, 'hash'],
+                  [:hash_end, nil],
+                  [:array_end, 'array'],
+                  [:add_value, true, 'boolean'],
+                  [:hash_end, nil]], handler.calls)
+  end
+
+  def test_multiple
+    handler = AllSaj.new()
+    json = %|[true][false]|
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([
+		   [:array_start, nil],
+                   [:add_value, true, nil],
+                   [:array_end, nil],
+		   [:array_start, nil],
+                   [:add_value, false, nil],
+                   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_io
+    handler = AllSaj.new()
+    json = %| [true,false]  |
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.load(StringIO.new(json))
+    assert_equal([
+		   [:array_start, nil],
+		   [:add_value, true, nil],
+		   [:add_value, false, nil],
+		   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_file
+    handler = AllSaj.new()
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.file('saj_test.json')
+    assert_equal([
+		   [:array_start, nil],
+		   [:add_value, true, nil],
+		   [:add_value, false, nil],
+		   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_default
+    handler = AllSaj.new()
+    json = %|[true]|
+    Oj::Parser.saj.handler = handler
+    Oj::Parser.saj.parse(json)
+    assert_equal([
+		   [:array_start, nil],
+                   [:add_value, true, nil],
+                   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_loc
+    handler = LocSaj.new()
+    Oj::Parser.saj.handler = handler
+    Oj::Parser.saj.parse($json)
+    assert_equal([[:hash_start, nil, 1, 1],
+                  [:array_start, 'array', 2, 12],
+                  [:hash_start, nil, 3, 5],
+                  [:add_value, 3, 'num', 4, 18],
+                  [:add_value, 'message', 'string', 5, 25],
+                  [:hash_start, 'hash', 6, 17],
+                  [:hash_start, 'h2', 7, 17],
+                  [:array_start, 'a', 8, 17],
+                  [:add_value, 1, nil, 8, 20],
+                  [:add_value, 2, nil, 8, 23],
+                  [:add_value, 3, nil, 8, 26],
+                  [:array_end, 'a', 8, 27],
+                  [:hash_end, 'h2', 9, 9],
+                  [:hash_end, 'hash', 10, 7],
+                  [:hash_end, nil, 11, 5],
+                  [:array_end, 'array', 12, 3],
+                  [:add_value, true, 'boolean', 13, 18],
+                  [:hash_end, nil, 14, 1]], handler.calls)
+  end
+
+end