oj 3.16.1 → 3.16.7

data/ext/oj/usual.c

@@ -281,7 +281,6 @@ static void close_object(ojParser p) {
     VALUE         *head = d->vhead + c->vi + 1;
     volatile VALUE obj  = rb_hash_new();
 
-#if HAVE_RB_HASH_BULK_INSERT
     for (vp = head; kp < d->ktail; kp++, vp += 2) {
         *vp = d->get_key(p, kp);
         if (sizeof(kp->buf) <= (size_t)kp->len) {
@@ -289,18 +288,15 @@ static void close_object(ojParser p) {
         }
     }
     rb_hash_bulk_insert(d->vtail - head, head, obj);
-#else
-    for (vp = head; kp < d->ktail; kp++, vp += 2) {
-        rb_hash_aset(obj, d->get_key(p, kp), *(vp + 1));
-        if (sizeof(kp->buf) <= (size_t)kp->len) {
-            OJ_R_FREE(kp->key);
-        }
-    }
-#endif
     d->ktail = d->khead + c->ki;
+
     d->vtail = head;
     head--;
     *head = obj;
+    if (1 == d->vtail - d->vhead && rb_block_given_p()) {
+        d->vtail = d->vhead;
+        rb_yield(obj);
+    }
 }
 
 static void close_object_class(ojParser p) {
@@ -341,7 +337,6 @@ static void close_object_create(ojParser p) {
         head++;
         if (Qnil == d->hash_class) {
             obj = rb_hash_new();
-#if HAVE_RB_HASH_BULK_INSERT
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
                 *vp = d->get_key(p, kp);
                 if (sizeof(kp->buf) <= (size_t)kp->len) {
@@ -349,14 +344,6 @@ static void close_object_create(ojParser p) {
                 }
             }
             rb_hash_bulk_insert(d->vtail - head, head, obj);
-#else
-            for (vp = head; kp < d->ktail; kp++, vp += 2) {
-                rb_hash_aset(obj, d->get_key(p, kp), *(vp + 1));
-                if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    OJ_R_FREE(kp->key);
-                }
-            }
-#endif
         } else {
             obj = rb_class_new_instance(0, NULL, d->hash_class);
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
@@ -373,7 +360,6 @@ static void close_object_create(ojParser p) {
         if (!d->ignore_json_create && rb_respond_to(clas, oj_json_create_id)) {
             volatile VALUE arg = rb_hash_new();
 
-#if HAVE_RB_HASH_BULK_INSERT
             for (vp = head; kp < d->ktail; kp++, vp += 2) {
                 *vp = d->get_key(p, kp);
                 if (sizeof(kp->buf) <= (size_t)kp->len) {
@@ -381,14 +367,6 @@ static void close_object_create(ojParser p) {
                 }
             }
             rb_hash_bulk_insert(d->vtail - head, head, arg);
-#else
-            for (vp = head; kp < d->ktail; kp++, vp += 2) {
-                rb_hash_aset(arg, d->get_key(p, kp), *(vp + 1));
-                if (sizeof(kp->buf) <= (size_t)kp->len) {
-                    OJ_R_FREE(kp->key);
-                }
-            }
-#endif
             obj = rb_funcall(clas, oj_json_create_id, 1, arg);
         } else {
             obj = rb_class_new_instance(0, NULL, clas);
@@ -599,7 +577,21 @@ static VALUE result(ojParser p) {
     Usual d = (Usual)p->ctx;
 
     if (d->vhead < d->vtail) {
-        return *d->vhead;
+        long            cnt = d->vtail - d->vhead;
+        volatile VALUE  ary;
+        volatile VALUE *vp;
+
+        if (1 == cnt) {
+            return *d->vhead;
+        }
+        ary = rb_ary_new();
+        for (vp = d->vhead; vp < d->vtail; vp++) {
+            rb_ary_push(ary, *vp);
+        }
+        return ary;
+    }
+    if (d->raise_on_empty) {
+        rb_raise(oj_parse_error_class, "empty string");
     }
     return Qnil;
 }
@@ -1066,6 +1058,20 @@ static VALUE opt_symbol_keys_set(ojParser p, VALUE value) {
     return (NULL != d->sym_cache) ? Qtrue : Qfalse;
 }
 
+static VALUE opt_raise_on_empty(ojParser p, VALUE value) {
+    Usual d = (Usual)p->ctx;
+
+    return d->raise_on_empty ? Qtrue : Qfalse;
+}
+
+static VALUE opt_raise_on_empty_set(ojParser p, VALUE value) {
+    Usual d = (Usual)p->ctx;
+
+    d->raise_on_empty = (Qtrue == value);
+
+    return d->raise_on_empty ? Qtrue : Qfalse;
+}
+
 static VALUE option(ojParser p, const char *key, VALUE value) {
     struct opt *op;
     struct opt  opts[] = {
@@ -1095,6 +1101,8 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
         {.name = "omit_null=", .func = opt_omit_null_set},
         {.name = "symbol_keys", .func = opt_symbol_keys},
         {.name = "symbol_keys=", .func = opt_symbol_keys_set},
+        {.name = "raise_on_empty", .func = opt_raise_on_empty},
+        {.name = "raise_on_empty=", .func = opt_raise_on_empty_set},
         {.name = NULL},
     };
 
@@ -1129,6 +1137,7 @@ void oj_init_usual(ojParser p, Usual d) {
     d->get_key            = cache_key;
     d->cache_keys         = true;
     d->ignore_json_create = false;
+    d->raise_on_empty     = false;
     d->cache_str          = 6;
     d->array_class        = Qnil;
     d->hash_class         = Qnil;

data/ext/oj/usual.h

@@ -60,6 +60,7 @@ typedef struct _usual {
     uint8_t miss_class;
     bool    cache_keys;
     bool    ignore_json_create;
+    bool    raise_on_empty;
 } *Usual;
 
 // Initialize the parser with the usual delegate. If the usual delegate is

data/ext/oj/val_stack.c

@@ -8,7 +8,7 @@
 #include "odd.h"
 #include "oj.h"
 
-static void mark(void *ptr) {
+static void stack_mark(void *ptr) {
     ValStack stack = (ValStack)ptr;
     Val      v;
 
@@ -46,6 +46,17 @@ static void mark(void *ptr) {
 #endif
 }
 
+static const rb_data_type_t oj_stack_type = {
+    "Oj/stack",
+    {
+        stack_mark,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 VALUE
 oj_stack_init(ValStack stack) {
 #ifdef HAVE_PTHREAD_MUTEX_INIT
@@ -70,7 +81,7 @@ oj_stack_init(ValStack stack) {
     stack->head->clen      = 0;
     stack->head->next      = NEXT_NONE;
 
-    return Data_Wrap_Struct(oj_cstack_class, mark, 0, stack);
+    return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);
 }
 
 const char *oj_stack_next_string(ValNext n) {

data/lib/oj/mimic.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: false
 
 require 'bigdecimal'
-begin
-  require 'ostruct'
-rescue Exception
-  # ignore
-end
+require 'ostruct'
 
 module Oj
 

data/lib/oj/schandler.rb

@@ -64,13 +64,14 @@ module Oj
   #
   #    hash_end
   #
-  # When a hash key is encountered the hash_key method is called with the parsed
-  # hash value key. The return value from the call is then used as the key in
-  # the key-value pair that follows.
+  #  At the end of a JSON object element the hash_end() callback is called if
+  #  public.
   #
   #    hash_key
   #
-  # At the end of a JSON object element the hash_end() callback is called if public.
+  # When a hash key is encountered the hash_key() method is called with the
+  # parsed hash value key. The return value from the call is then used as the
+  # key in the key-value pair that follows.
   #
   #    hash_set
   #

data/lib/oj/version.rb

@@ -1,4 +1,4 @@
 module Oj
   # Current version of the module.
-  VERSION = '3.16.1'
+  VERSION = '3.16.7'
 end

data/test/activesupport6/encoding_test.rb

@@ -74,42 +74,77 @@ class TestJSONEncoding < ActiveSupport::TestCase
     ActiveSupport.escape_html_entities_in_json = false
   end
 
-  def test_utf8_string_encoded_properly
-    # The original test seems to expect that
-    # ActiveSupport.escape_html_entities_in_json reverts to true even after
-    # being set to false. I haven't been able to figure that out so the value is
-    # set to true, the default, before running the test. This might be wrong but
-    # for now it will have to do.
-    ActiveSupport.escape_html_entities_in_json = true
-    result = ActiveSupport::JSON.encode("€2.99")
-    assert_equal '"€2.99"', result
-    assert_equal(Encoding::UTF_8, result.encoding)
-
-    result = ActiveSupport::JSON.encode("✎☺")
-    assert_equal '"✎☺"', result
-    assert_equal(Encoding::UTF_8, result.encoding)
+  def test_hash_keys_encoding_without_escaping
+    assert_equal "{\"<>\":\"<>\"}", ActiveSupport::JSON.encode("<>" => "<>")
   end
 
-  def test_non_utf8_string_transcodes
-    s = "二".encode("Shift_JIS")
-    result = ActiveSupport::JSON.encode(s)
-    assert_equal '"二"', result
-    assert_equal Encoding::UTF_8, result.encoding
+  module UnicodeTests
+    def test_utf8_string_encoded_properly
+      result = ActiveSupport::JSON.encode("€2.99")
+      assert_equal '"€2.99"', result
+      assert_equal(Encoding::UTF_8, result.encoding)
+
+      result = ActiveSupport::JSON.encode("✎☺")
+      assert_equal '"✎☺"', result
+      assert_equal(Encoding::UTF_8, result.encoding)
+    end
+
+    def test_non_utf8_string_transcodes
+      s = "二".encode("Shift_JIS")
+      result = ActiveSupport::JSON.encode(s)
+      assert_equal '"二"', result
+      assert_equal Encoding::UTF_8, result.encoding
+    end
+
+    def test_wide_utf8_chars
+      w = "𠜎"
+      result = ActiveSupport::JSON.encode(w)
+      assert_equal '"𠜎"', result
+    end
+
+    def test_wide_utf8_roundtrip
+      hash = { string: "𐒑" }
+      json = ActiveSupport::JSON.encode(hash)
+      decoded_hash = ActiveSupport::JSON.decode(json)
+      assert_equal "𐒑", decoded_hash["string"]
+    end
+
+    def test_invalid_encoding_raises
+      s = "\xAE\xFF\x9F"
+      refute s.valid_encoding?
+
+      # n.b. this raises EncodingError, because we didn't call Oj.mimic_JSON in the test setup; but,
+      # if you do that (even indirectly through Oj.optimize_rails), then this raises a
+      # JSON::GeneratorError instead of an EncodingError.
+      assert_raises(EncodingError) do
+        ActiveSupport::JSON.encode([s])
+      end
+    end
   end
 
-  def test_wide_utf8_chars
-    w = "𠜎"
-    result = ActiveSupport::JSON.encode(w)
-    assert_equal '"𠜎"', result
+  module UnicodeTestsWithEscapingOn
+    def setup
+      ActiveSupport.escape_html_entities_in_json = true
+    end
+
+    def teardown
+      ActiveSupport.escape_html_entities_in_json = false
+    end
+
+    include UnicodeTests
   end
 
-  def test_wide_utf8_roundtrip
-    hash = { string: "𐒑" }
-    json = ActiveSupport::JSON.encode(hash)
-    decoded_hash = ActiveSupport::JSON.decode(json)
-    assert_equal "𐒑", decoded_hash["string"]
+  module UnicodeTestsWithEscapingOff
+    def setup
+      ActiveSupport.escape_html_entities_in_json = false
+    end
+
+    include UnicodeTests
   end
 
+  include UnicodeTestsWithEscapingOn
+  include UnicodeTestsWithEscapingOff
+
   def test_hash_key_identifiers_are_always_quoted
     values = { 0 => 0, 1 => 1, :_ => :_, "$" => "$", "a" => "a", :A => :A, :A0 => :A0, "A0B" => "A0B" }
     assert_equal %w( "$" "A" "A0" "A0B" "_" "a" "0" "1" ).sort, object_keys(ActiveSupport::JSON.encode(values))

data/test/activesupport7/abstract_unit.rb

@@ -19,7 +19,10 @@ require "active_support"
 Thread.abort_on_exception = true
 
 # Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
+if ActiveSupport::Deprecation.respond_to?(:debug)
+  # Rails 7.2 does not have ActiveSupport::Deprecation.debug
+  ActiveSupport::Deprecation.debug = true
+end
 
 # Default to old to_time behavior but allow running tests with new behavior
 ActiveSupport.to_time_preserves_timezone = ENV["PRESERVE_TIMEZONES"] == "1"

data/test/activesupport7/encoding_test.rb

@@ -8,9 +8,18 @@ require "active_support/time"
 require_relative "time_zone_test_helpers"
 require_relative "encoding_test_cases"
 
+require 'oj'
+# Sets the ActiveSupport encoder to be Oj and also wraps the setting of globals.
+Oj::Rails.set_encoder()
+Oj::Rails.optimize()
+
 class TestJSONEncoding < ActiveSupport::TestCase
   include TimeZoneTestHelpers
 
+  def test_is_actually_oj
+    assert_equal Oj::Rails::Encoder, ActiveSupport.json_encoder
+  end
+
   def sorted_json(json)
     if json.start_with?("{") && json.end_with?("}")
       "{" + json[1..-2].split(",").sort.join(",") + "}"
@@ -61,36 +70,77 @@ class TestJSONEncoding < ActiveSupport::TestCase
     ActiveSupport.escape_html_entities_in_json = false
   end
 
-  def test_utf8_string_encoded_properly
-    result = ActiveSupport::JSON.encode("€2.99")
-    assert_equal '"€2.99"', result
-    assert_equal(Encoding::UTF_8, result.encoding)
-
-    result = ActiveSupport::JSON.encode("✎☺")
-    assert_equal '"✎☺"', result
-    assert_equal(Encoding::UTF_8, result.encoding)
+  def test_hash_keys_encoding_without_escaping
+    assert_equal "{\"<>\":\"<>\"}", ActiveSupport::JSON.encode("<>" => "<>")
   end
 
-  def test_non_utf8_string_transcodes
-    s = "二".encode("Shift_JIS")
-    result = ActiveSupport::JSON.encode(s)
-    assert_equal '"二"', result
-    assert_equal Encoding::UTF_8, result.encoding
+  module UnicodeTests
+    def test_utf8_string_encoded_properly
+      result = ActiveSupport::JSON.encode("€2.99")
+      assert_equal '"€2.99"', result
+      assert_equal(Encoding::UTF_8, result.encoding)
+
+      result = ActiveSupport::JSON.encode("✎☺")
+      assert_equal '"✎☺"', result
+      assert_equal(Encoding::UTF_8, result.encoding)
+    end
+
+    def test_non_utf8_string_transcodes
+      s = "二".encode("Shift_JIS")
+      result = ActiveSupport::JSON.encode(s)
+      assert_equal '"二"', result
+      assert_equal Encoding::UTF_8, result.encoding
+    end
+
+    def test_wide_utf8_chars
+      w = "𠜎"
+      result = ActiveSupport::JSON.encode(w)
+      assert_equal '"𠜎"', result
+    end
+
+    def test_wide_utf8_roundtrip
+      hash = { string: "𐒑" }
+      json = ActiveSupport::JSON.encode(hash)
+      decoded_hash = ActiveSupport::JSON.decode(json)
+      assert_equal "𐒑", decoded_hash["string"]
+    end
+
+    def test_invalid_encoding_raises
+      s = "\xAE\xFF\x9F"
+      refute s.valid_encoding?
+
+      # n.b. this raises EncodingError, because we didn't call Oj.mimic_JSON in the test setup; but,
+      # if you do that (even indirectly through Oj.optimize_rails), then this raises a
+      # JSON::GeneratorError instead of an EncodingError.
+      assert_raises(EncodingError) do
+        ActiveSupport::JSON.encode([s])
+      end
+    end
   end
 
-  def test_wide_utf8_chars
-    w = "𠜎"
-    result = ActiveSupport::JSON.encode(w)
-    assert_equal '"𠜎"', result
+  module UnicodeTestsWithEscapingOn
+    def setup
+      ActiveSupport.escape_html_entities_in_json = true
+    end
+
+    def teardown
+      ActiveSupport.escape_html_entities_in_json = false
+    end
+
+    include UnicodeTests
   end
 
-  def test_wide_utf8_roundtrip
-    hash = { string: "𐒑" }
-    json = ActiveSupport::JSON.encode(hash)
-    decoded_hash = ActiveSupport::JSON.decode(json)
-    assert_equal "𐒑", decoded_hash["string"]
+  module UnicodeTestsWithEscapingOff
+    def setup
+      ActiveSupport.escape_html_entities_in_json = false
+    end
+
+    include UnicodeTests
   end
 
+  include UnicodeTestsWithEscapingOn
+  include UnicodeTestsWithEscapingOff
+
   def test_hash_key_identifiers_are_always_quoted
     values = { 0 => 0, 1 => 1, :_ => :_, "$" => "$", "a" => "a", :A => :A, :A0 => :A0, "A0B" => "A0B" }
     assert_equal %w( "$" "A" "A0" "A0B" "_" "a" "0" "1" ).sort, object_keys(ActiveSupport::JSON.encode(values))

data/test/foo.rb

@@ -5,16 +5,22 @@ $LOAD_PATH << '.'
 $LOAD_PATH << File.join(__dir__, '../lib')
 $LOAD_PATH << File.join(__dir__, '../ext')
 
-require 'active_support'
-require 'json'
 require 'oj'
 
-Oj.mimic_JSON()
-# Oj::Rails.mimic_JSON()
+reader, writer = IO.pipe
 
-begin
-  ::JSON.parse('{ "foo": 84e }')
-  #::JSON.parse('{ "foo": 84eb234 }')
-rescue Exception => e
-  puts "#{e.class}: #{e.message}"
-end
+thread =
+  Thread.new do
+    5.times do |id|
+      Oj.to_stream(writer, { "id" => id })
+      sleep(1)
+    end
+
+    writer.close
+  end
+
+p = Oj::Parser.new(:usual)
+p.load(reader) { |data| puts "#{Time.now} -- ID: #{data["id"]}" }
+
+reader.close
+thread.join

data/test/json_gem/json_generator_test.rb

@@ -142,6 +142,8 @@ class JSONGeneratorTest < Test::Unit::TestCase
     # seems to occur on travis but not locally.
     actual = state.to_h
     actual.delete(:escape_slash)
+    actual.delete(:strict)
+    actual.delete(:script_safe)
     assert_equal({
       :allow_nan             => false,
       :array_nl              => "\n",
@@ -162,6 +164,8 @@ class JSONGeneratorTest < Test::Unit::TestCase
     # seems to occur on travis but not locally.
     actual = state.to_h
     actual.delete(:escape_slash)
+    actual.delete(:strict)
+    actual.delete(:script_safe)
     assert_equal({
       :allow_nan             => false,
       :array_nl              => "",
@@ -182,6 +186,8 @@ class JSONGeneratorTest < Test::Unit::TestCase
     # seems to occur on travis but not locally.
     actual = state.to_h
     actual.delete(:escape_slash)
+    actual.delete(:strict)
+    actual.delete(:script_safe)
     assert_equal({
       :allow_nan             => false,
       :array_nl              => "",

data/test/perf_dump.rb

@@ -28,7 +28,7 @@ opts.parse(ARGV)
   'd' => [ true, [false, [-123_456_789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
   'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
   'f' => nil,     # nil
-  'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
+  'h' => { 'a' => { 'b' => { 'c' => { 'd' => { 'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
   'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
 }
 

data/test/prec.rb

@@ -2,9 +2,9 @@
 
 require 'oj'
 
-extras = {'locationLng' => -97.14690769100295}
+extras = { 'locationLng' => -97.14690769100295 }
 
-Oj.default_options = {float_precision: 17}
+Oj.default_options = { float_precision: 17 }
 
 encoded = Oj.dump(extras)
 puts encoded
@@ -15,8 +15,8 @@ require 'active_record'
 Oj::Rails.set_encoder()
 Oj::Rails.set_decoder()
 
-Oj.default_options = {float_precision: 17}
-# Using Oj rails encoder, gets the correct value: {'locationLng':-97.14690769100295}
+Oj.default_options = { float_precision: 17 }
+# Using Oj rails encoder, gets the correct value: { 'locationLng':-97.14690769100295 }
 encoded = ActiveSupport::JSON.encode(extras)
 puts encoded
 puts ActiveSupport::JSON.decode(encoded)

data/test/test_compat.rb

@@ -468,7 +468,7 @@ class CompatJuice < Minitest::Test
 
   def test_arg_passing
     json = Oj.to_json(Argy.new(), :max_nesting => 40)
-    assert_equal(%|{"args":"[{:max_nesting=>40}]"}|, json)
+    assert_match(/.*max_nesting.*40.*/, json)
   end
 
   def test_max_nesting

data/test/test_custom.rb

@@ -503,8 +503,9 @@ class CustomJuice < Minitest::Test
     # These two forms will lose precision while dumping as they don't
     # preserve full precision. We check that a dumped version is equal
     # to that version loaded and dumped a second time, but don't check
-    # that the loaded Ruby objects is still the same as the original.
+    # that the loaded Ruby object is still the same as the original.
     dump_load_dump(obj, false, :time_format => :xmlschema, :create_id => '^o', :create_additions => true)
+    dump_load_dump(obj, false, :time_format => :xmlschema, :create_id => '^o', :create_additions => true, second_precision: 3)
     dump_load_dump(obj, false, :time_format => :ruby, :create_id => '^o', :create_additions => true)
   end
 

data/test/test_object.rb

@@ -951,6 +951,20 @@ class ObjectJuice < Minitest::Test
     dump_and_load(DateTime.new(2012, 6, 19, 13, 5, Rational(7_123_456_789, 1_000_000_000)), false)
   end
 
+  def test_odd_xml_time
+    str = "2023-01-01T00:00:00Z"
+    assert_equal(Time.parse(str), Oj.load('{"^t":"' + str + '"}', mode: :object))
+
+    str = "2023-01-01T00:00:00.3Z"
+    assert_equal(Time.parse(str), Oj.load('{"^t":"' + str + '"}', mode: :object))
+
+    str = "2023-01-01T00:00:00.123456789123456789Z"
+    assert_equal(Time.parse(str), Oj.load('{"^t":"' + str + '"}', mode: :object))
+
+    str = "2023-01-01T00:00:00.123456789123456789123456789Z"
+    assert_equal(Time.parse(str), Oj.load('{"^t":"' + str + '"}', mode: :object))
+  end
+
   def test_bag
     json = %{{
   "^o":"ObjectJuice::Jem",

data/test/test_parser_debug.rb

@@ -3,7 +3,7 @@
 
 $LOAD_PATH << __dir__
 @oj_dir = File.dirname(File.expand_path(__dir__))
-%w(lib ext).each do |dir|
+%w[lib ext].each do |dir|
   $LOAD_PATH << File.join(@oj_dir, dir)
 end
 

data/test/test_parser_usual.rb

@@ -114,6 +114,30 @@ class UsualTest < Minitest::Test
     assert_equal(Float, doc.class)
   end
 
+  def test_multi_parse
+    p = Oj::Parser.new(:usual)
+    out = []
+    p.parse('{"a":1}{"b":{"x":2}} {"c":3}') { |j| out.push(j) }
+    assert_equal([{'a'=>1}, {'b'=>{'x'=>2}},{'c'=>3}], out)
+  end
+
+  def test_multi_load
+    p = Oj::Parser.new(:usual)
+    out = []
+    r, w = IO.pipe
+    thread = Thread.new do
+      ['{"a":1}', '{"b":{"x"', ':2}}{"c":', '3}'].each { |seg|
+        w.write(seg)
+        sleep(0.1)
+      }
+      w.close
+    end
+    p.load(r) { |j| out.push(j) }
+    r.close
+    thread.join
+    assert_equal([{'a'=>1}, {'b'=>{'x'=>2}},{'c'=>3}], out)
+  end
+
   def test_omit_null
     p = Oj::Parser.new(:usual)
     p.omit_null = true
@@ -147,6 +171,16 @@ class UsualTest < Minitest::Test
     assert_equal(MyHash, doc.class)
   end
 
+  def test_empty
+    p = Oj::Parser.new(:usual)
+    p.raise_on_empty = false
+    doc = p.parse('  ')
+    assert_nil(doc)
+
+    p.raise_on_empty = true
+    assert_raises(Oj::ParseError) { p.parse('  ') }
+  end
+
   class MyClass
     attr_accessor :a
     attr_accessor :b