oj 3.11.5 → 3.16.5

data/test/test_scp.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
+$LOAD_PATH << __dir__
 
 require 'helper'
 require 'socket'
@@ -23,23 +23,22 @@ $json = %{{
 }}
 
 class NoHandler < Oj::ScHandler
-  def initialize()
-  end
 end
 
 class AllHandler < Oj::ScHandler
   attr_accessor :calls
 
-  def initialize()
+  def initialize
+    super
     @calls = []
   end
 
-  def hash_start()
+  def hash_start
     @calls << [:hash_start]
     {}
   end
 
-  def hash_end()
+  def hash_end
     @calls << [:hash_end]
   end
 
@@ -47,15 +46,16 @@ class AllHandler < Oj::ScHandler
     @calls << [:hash_key, key]
     return 'too' if 'two' == key
     return :symbol if 'symbol' == key
+
     key
   end
 
-  def array_start()
+  def array_start
     @calls << [:array_start]
     []
   end
 
-  def array_end()
+  def array_end
     @calls << [:array_end]
   end
 
@@ -63,11 +63,11 @@ class AllHandler < Oj::ScHandler
     @calls << [:add_value, value]
   end
 
-  def hash_set(h, key, value)
+  def hash_set(_h, key, value)
     @calls << [:hash_set, key, value]
   end
 
-  def array_append(a, value)
+  def array_append(_a, value)
     @calls << [:array_append, value]
   end
 
@@ -75,18 +75,19 @@ end # AllHandler
 
 class Closer < AllHandler
   attr_accessor :io
+
   def initialize(io)
     super()
     @io = io
   end
 
-  def hash_start()
+  def hash_start
     @calls << [:hash_start]
     @io.close
     {}
   end
 
-  def hash_set(h, key, value)
+  def hash_set(_h, key, value)
     @calls << [:hash_set, key, value]
     @io.close
   end
@@ -135,14 +136,14 @@ class ScpTest < Minitest::Test
     handler = AllHandler.new()
     json = %{12345}
     Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, 12345]], handler.calls)
+    assert_equal([[:add_value, 12_345]], handler.calls)
   end
 
   def test_float
     handler = AllHandler.new()
     json = %{12345.6789}
     Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, 12345.6789]], handler.calls)
+    assert_equal([[:add_value, 12_345.6789]], handler.calls)
   end
 
   def test_float_exp
@@ -151,7 +152,7 @@ class ScpTest < Minitest::Test
     Oj.sc_parse(handler, 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)
+    assert_equal((12_345.6789e7 * 10_000).to_i, (handler.calls[0][1] * 10_000).to_i)
   end
 
   def test_array_empty
@@ -230,9 +231,9 @@ class ScpTest < Minitest::Test
                   [:array_start],
                   [:hash_start],
                   [:hash_key, 'num'],
-                  [:hash_set, "num", 3],
+                  [:hash_set, 'num', 3],
                   [:hash_key, 'string'],
-                  [:hash_set, "string", "message"],
+                  [:hash_set, 'string', 'message'],
                   [:hash_key, 'hash'],
                   [:hash_start],
                   [:hash_key, 'h2'],
@@ -243,17 +244,17 @@ class ScpTest < Minitest::Test
                   [:array_append, 2],
                   [:array_append, 3],
                   [:array_end],
-                  [:hash_set, "a", []],
+                  [:hash_set, 'a', []],
                   [:hash_end],
-                  [:hash_set, "h2", {}],
+                  [:hash_set, 'h2', {}],
                   [:hash_end],
-                  [:hash_set, "hash", {}],
+                  [:hash_set, 'hash', {}],
                   [:hash_end],
                   [:array_append, {}],
                   [:array_end],
-                  [:hash_set, "array", []],
+                  [:hash_set, 'array', []],
                   [:hash_key, 'boolean'],
-                  [:hash_set, "boolean", true],
+                  [:hash_set, 'boolean', true],
                   [:hash_end],
                   [:add_value, {}]], handler.calls)
   end
@@ -320,8 +321,7 @@ class ScpTest < Minitest::Test
   end
 
   def test_pipe
-    # Windows does not support fork
-    return if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+    skip 'needs fork' unless Process.respond_to?(:fork)
 
     handler = AllHandler.new()
     json = %{{"one":true,"two":false}}
@@ -347,18 +347,15 @@ class ScpTest < Minitest::Test
   end
 
   def test_bad_bignum
-    if '2.4.0' < RUBY_VERSION
-      handler = AllHandler.new()
-      json = %|{"big":-e123456789}|
-      assert_raises Exception do # Can be either Oj::ParseError or ArgumentError depending on Ruby version
-	Oj.sc_parse(handler, json)
-      end
+    handler = AllHandler.new()
+    json = %|{"big":-e123456789}|
+    assert_raises Exception do # Can be either Oj::ParseError or ArgumentError depending on Ruby version
+      Oj.sc_parse(handler, json)
     end
   end
 
   def test_pipe_close
-    # Windows does not support fork
-    return if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+    skip 'needs fork' unless Process.respond_to?(:fork)
 
     json = %{{"one":true,"two":false}}
     IO.pipe do |read_io, write_io|
@@ -372,7 +369,7 @@ class ScpTest < Minitest::Test
         rescue Exception => e
           err = e.class.to_s
         end
-        assert_equal("IOError", err)
+        assert_equal('IOError', err)
         assert_equal([[:hash_start],
                       [:hash_key, 'one'],
                       [:hash_set, 'one', true]], handler.calls)
@@ -381,8 +378,8 @@ class ScpTest < Minitest::Test
         write_io.write json[0..11]
         sleep(0.1)
         begin
-          write_io.write json[12..-1]
-        rescue Exception => e
+          write_io.write json[12..]
+        rescue Exception
           # ignore, should fail to write
         end
         write_io.close
@@ -399,15 +396,16 @@ class ScpTest < Minitest::Test
       # Not able to open a socket to run the test. Might be Travis.
       return
     end
-    Thread.start(json) do |j|
+    Thread.start(json) do |_j|
       c = server.accept()
       c.puts json[0..11]
       10.times {
         break if c.closed?
+
         sleep(0.1)
       }
       unless c.closed?
-        c.puts json[12..-1]
+        c.puts json[12..]
         c.close
       end
     end
@@ -424,7 +422,7 @@ class ScpTest < Minitest::Test
     rescue Exception => e
       err = e.class.to_s
     end
-    assert_equal("IOError", err)
+    assert_equal('IOError', err)
     assert_equal([[:hash_start],
                   [:hash_key, 'one'],
                   [:hash_set, 'one', true]], handler.calls)

data/test/test_strict.rb

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
-# encoding: utf-8
+# frozen_string_literal: true
 
-$: << File.dirname(__FILE__)
-$oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH << __dir__
+@oj_dir = File.dirname(File.expand_path(__dir__))
 %w(lib ext).each do |dir|
-  $: << File.join($oj_dir, dir)
+  $LOAD_PATH << File.join(@oj_dir, dir)
 end
 
 require 'minitest'
@@ -52,16 +52,16 @@ class StrictJuice < Minitest::Test
 
   def test_fixnum
     dump_and_load(0, false)
-    dump_and_load(12345, false)
-    dump_and_load(-54321, false)
+    dump_and_load(12_345, false)
+    dump_and_load(-54_321, false)
     dump_and_load(1, false)
   end
 
   def test_float
     dump_and_load(0.0, false)
-    dump_and_load(12345.6789, false)
+    dump_and_load(12_345.6789, false)
     dump_and_load(70.35, false)
-    dump_and_load(-54321.012, false)
+    dump_and_load(-54_321.012, false)
     dump_and_load(1.7775, false)
     dump_and_load(2.5024, false)
     dump_and_load(2.48e16, false)
@@ -69,6 +69,16 @@ class StrictJuice < Minitest::Test
     dump_and_load(-2.48e100 * 1.0e10, false)
   end
 
+  def test_invalid_float
+    begin
+      Oj.load("64ecb72d29191067f91ff95b")
+    rescue Oj::ParseError => e
+      assert(e.message == "Invalid float")
+      return
+    end
+    assert(false, "*** expected an exception")
+  end
+
   def test_nan_dump
     assert_equal('null', Oj.dump(0/0.0, :nan => :null))
     assert_equal('3.3e14159265358979323846', Oj.dump(0/0.0, :nan => :huge))
@@ -78,7 +88,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_infinity_dump
@@ -90,7 +100,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_neg_infinity_dump
@@ -102,7 +112,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_string
@@ -115,15 +125,11 @@ class StrictJuice < Minitest::Test
   def test_encode
     opts = Oj.default_options
     Oj.default_options = { :ascii_only => false }
-    unless 'jruby' == $ruby
-      dump_and_load("ぴーたー", false)
-    end
+    dump_and_load('ぴーたー', false)
     Oj.default_options = { :ascii_only => true }
-    json = Oj.dump("ぴーたー")
+    json = Oj.dump('ぴーたー')
     assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
-    unless 'jruby' == $ruby
-      dump_and_load("ぴーたー", false)
-    end
+    dump_and_load('ぴーたー', false)
     Oj.default_options = opts
   end
 
@@ -152,15 +158,17 @@ class StrictJuice < Minitest::Test
   end
 
   def test_array_deep
-    dump_and_load([1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20]]]]]]]]]]]]]]]]]]]], false)
+    dump_and_load([1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20]]]]]]]]]]]]]]]]]]]], false)
   end
 
   def test_deep_nest
+    skip 'TruffleRuby causes SEGV' if RUBY_ENGINE == 'truffleruby'
+
     begin
-      n = 10000
-      Oj.strict_load('[' * n + ']' * n)
+      n = 10_000
+      Oj.strict_load(('[' * n) + (']' * n))
     rescue Exception => e
-      assert(false, e.message)
+      refute(e.message)
     end
   end
 
@@ -207,7 +215,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_bignum_object
@@ -236,7 +244,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_range
@@ -246,7 +254,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   # Stream IO
@@ -263,13 +271,13 @@ class StrictJuice < Minitest::Test
   end
 
   def test_io_file
-    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
-    File.open(filename, 'w') { |f| f.write(%{{
+    filename = File.join(__dir__, 'open_file_test.json')
+    File.write(filename, %{{
   "x":true,
   "y":58,
   "z": [1,2,3]
 }
-}) }
+})
     f = File.new(filename)
     obj = Oj.strict_load(f)
     f.close()
@@ -289,7 +297,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_class
@@ -299,7 +307,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   def test_module
@@ -309,7 +317,7 @@ class StrictJuice < Minitest::Test
       assert(true)
       return
     end
-    assert(false, "*** expected an exception")
+    assert(false, '*** expected an exception')
   end
 
   # symbol_keys option
@@ -421,7 +429,7 @@ class StrictJuice < Minitest::Test
   def dump_and_load(obj, trace=false)
     json = Oj.dump(obj, :indent => 2)
     puts json if trace
-    loaded = Oj.strict_load(json);
+    loaded = Oj.strict_load(json)
     if obj.nil?
       assert_nil(loaded)
     else