oj 2.9.4 → 2.9.5

data/test/test_gc.rb

@@ -1,38 +1,36 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-# Ubuntu does not accept arguments to ruby when called using env. To get
-# warnings to show up the -w options is required. That can be set in the RUBYOPT
-# environment variable.
-# export RUBYOPT=-w
+$: << File.dirname(__FILE__)
 
-$VERBOSE = true
+require 'helper'
 
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
+class GCTest < Minitest::Test
+  class Goo
+    attr_accessor :x, :child
 
-require 'test/unit'
-require 'oj'
+    def initialize(x, child)
+      @x = x
+      @child = child
+    end
 
-class Goo
-  attr_accessor :x, :child
+    def to_hash()
+      { 'json_class' => "#{self.class}", 'x' => x, 'child' => child }
+    end
 
-  def initialize(x, child)
-    @x = x
-    @child = child
-  end
-  
-  def to_hash()
-    { 'json_class' => "#{self.class}", 'x' => x, 'child' => child }
-  end
+    def self.json_create(h)
+      GC.start
+      self.new(h['x'], h['child'])
+    end
+  end # Goo
 
-  def self.json_create(h)
-    GC.start
-    self.new(h['x'], h['child'])
+  def setup
+    @default_options = Oj.default_options
   end
-end # Goo
 
-class GCTest < ::Test::Unit::TestCase
+  def teardown
+    Oj.default_options = @default_options
+  end
 
   # if no crash then the GC marking is working
   def test_parse_compat_gc

data/test/test_object.rb

@@ -1,158 +1,143 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
-# required. That can be set in the RUBYOPT environment variable.
-# export RUBYOPT=-w
+$: << File.dirname(__FILE__)
 
-$VERBOSE = true
+require 'helper'
 
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
+class ObjectJuice < Minitest::Test
+  class Jeez
+    attr_accessor :x, :y
 
-require 'test/unit'
-require 'stringio'
-require 'date'
-require 'bigdecimal'
-require 'oj'
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
 
-$ruby = RUBY_DESCRIPTION.split(' ')[0]
-$ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
+    def eql?(o)
+      self.class == o.class && @x == o.x && @y == o.y
+    end
+    alias == eql?
 
-class Jeez
-  attr_accessor :x, :y
+    def to_json(*a)
+      %{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
+    end
 
-  def initialize(x, y)
-    @x = x
-    @y = y
-  end
+    def self.json_create(h)
+      self.new(h['x'], h['y'])
+    end
+  end # Jeez
 
-  def eql?(o)
-    self.class == o.class && @x == o.x && @y == o.y
-  end
-  alias == eql?
-  
-  def to_json(*a)
-    %{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
-  end
+  module One
+    module Two
+      module Three
+        class Deep
 
-  def self.json_create(h)
-    self.new(h['x'], h['y'])
-  end
-end # Jeez
+          def initialize()
+          end
 
-module One
-  module Two
-    module Three
-      class Deep
+          def eql?(o)
+            self.class == o.class
+          end
+          alias == eql?
 
-        def initialize()
-        end
+          def to_hash()
+            {'json_class' => "#{self.class.name}"}
+          end
 
-        def eql?(o)
-          self.class == o.class
-        end
-        alias == eql?
+          def to_json(*a)
+            %{{"json_class":"#{self.class.name}"}}
+          end
 
-        def to_hash()
-          {'json_class' => "#{self.class.name}"}
-        end
+          def self.json_create(h)
+            self.new()
+          end
+        end # Deep
+      end # Three
+    end # Two
 
-        def to_json(*a)
-          %{{"json_class":"#{self.class.name}"}}
-        end
+    class Stuck2 < Struct.new(:a, :b)
+    end
 
-        def self.json_create(h)
-          self.new()
-        end
-      end # Deep
-    end # Three
-  end # Two
+  end # One
 
-  class Stuck2 < Struct.new(:a, :b)
+  class Stuck < Struct.new(:a, :b)
   end
 
-end # One
+  class Strung < String
 
-class Stuck < Struct.new(:a, :b)
-end
-
-class Strung < String
+    def initialize(str, safe)
+      super(str)
+      @safe = safe
+    end
 
-  def initialize(str, safe)
-    super(str)
-    @safe = safe
-  end
+    def safe?()
+      @safe
+    end
 
-  def safe?()
-    @safe
-  end
+    def self.create(str, safe)
+      new(str, safe)
+    end
 
-  def self.create(str, safe)
-    new(str, safe)
-  end
+    def eql?(o)
+      super && self.class == o.class && @safe == o.safe?
+    end
+    alias == eql?
 
-  def eql?(o)
-    super && self.class == o.class && @safe == o.safe?
+    def inspect()
+      return super + '(' + @safe + ')'
+    end
   end
-  alias == eql?
 
-  def inspect()
-    return super + '(' + @safe + ')'
-  end
-end
+  class AutoStrung < String
+    attr_accessor :safe
 
-class AutoStrung < String
-  attr_accessor :safe
+    def initialize(str, safe)
+      super(str)
+      @safe = safe
+    end
 
-  def initialize(str, safe)
-    super(str)
-    @safe = safe
+    def eql?(o)
+      self.class == o.class && super(o) && @safe == o.safe
+    end
+    alias == eql?
   end
 
-  def eql?(o)
-    self.class == o.class && super(o) && @safe == o.safe
-  end
-  alias == eql?
-end
+  class AutoArray < Array
+    attr_accessor :safe
 
-class AutoArray < Array
-  attr_accessor :safe
+    def initialize(a, safe)
+      super(a)
+      @safe = safe
+    end
 
-  def initialize(a, safe)
-    super(a)
-    @safe = safe
+    def eql?(o)
+      self.class == o.class && super(o) && @safe == o.safe
+    end
+    alias == eql?
   end
 
-  def eql?(o)
-    self.class == o.class && super(o) && @safe == o.safe
-  end
-  alias == eql?
-end
+  class AutoHash < Hash
+    attr_accessor :safe
 
-class AutoHash < Hash
-  attr_accessor :safe
+    def initialize(h, safe)
+      super(h)
+      @safe = safe
+    end
 
-  def initialize(h, safe)
-    super(h)
-    @safe = safe
+    def eql?(o)
+      self.class == o.class && super(o) && @safe == o.safe
+    end
+    alias == eql?
   end
 
-  def eql?(o)
-    self.class == o.class && super(o) && @safe == o.safe
+  def setup
+    @default_options = Oj.default_options
   end
-  alias == eql?
-end
 
-def hash_eql(h1, h2)
-  return false if h1.size != h2.size
-  h1.keys.each do |k|
-    return false unless h1[k] == h2[k]
+  def teardown
+    Oj.default_options = @default_options
   end
-  true
-end
-
-class ObjectJuice < ::Test::Unit::TestCase
 
   def test_nil
     dump_and_load(nil, false)
@@ -297,7 +282,7 @@ class ObjectJuice < ::Test::Unit::TestCase
   end
 
   def test_io_file
-    filename = 'open_file_test.json'
+    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
     File.open(filename, 'w') { |f| f.write(%{{
   "x":true,
   "y":58,
@@ -414,6 +399,7 @@ class ObjectJuice < ::Test::Unit::TestCase
   end
 
   def test_mixed_hash_object
+    Oj.default_options = { :mode => :object }
     json = Oj.dump({ 1 => true, 'nil' => nil, :sim => 4 })
     h = Oj.object_load(json)
     assert_equal({ 1 => true, 'nil' => nil, :sim => 4 }, h)

data/test/test_saj.rb

@@ -1,18 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
-# required. That can be set in the RUBYOPT environment variable.
-# export RUBYOPT=-w
+$: << File.dirname(__FILE__)
 
-$VERBOSE = true
-
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
-
-require 'test/unit'
-require 'oj'
-require 'pp'
+require 'helper'
 
 $json = %{{
   "array": [
@@ -62,7 +53,16 @@ class AllSaj < Oj::Saj
 
 end # AllSaj
 
-class SajTest < ::Test::Unit::TestCase
+class SajTest < Minitest::Test
+
+  def setup
+    @default_options = Oj.default_options
+  end
+
+  def teardown
+    Oj.default_options = @default_options
+  end
+
   def test_nil
     handler = AllSaj.new()
     json = %{null}
@@ -177,8 +177,10 @@ class SajTest < ::Test::Unit::TestCase
     handler = AllSaj.new()
     json = %{12345xyz}
     Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, 12345, nil],
-                  [:error, "invalid format, extra characters at line 1, column 6 [saj.c:688]", 1, 6]], handler.calls)
+    assert_equal([:add_value, 12345, nil], handler.calls.first)
+    type, message, line, column = handler.calls.last
+    assert_equal([:error, 1, 6], [type, line, column])
+    assert_match(%r{invalid format, extra characters at line 1, column 6 \[(?:[a-z\.]+/)*saj\.c:\d+\]}, message)
   end
 
 end

data/test/test_scp.rb

@@ -1,18 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
-# required. That can be set in the RUBYOPT environment variable.
-# export RUBYOPT=-w
+$: << File.dirname(__FILE__)
 
-$VERBOSE = true
-
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
-
-require 'test/unit'
-require 'oj'
-require 'pp'
+require 'helper'
 
 $json = %{{
   "array": [
@@ -66,14 +57,22 @@ class AllHandler < Oj::ScHandler
   def hash_set(h, key, value)
     @calls << [:hash_set, key, value]
   end
-  
+
   def array_append(a, value)
     @calls << [:array_append, value]
   end
 
 end # AllHandler
 
-class ScpTest < ::Test::Unit::TestCase
+class ScpTest < Minitest::Test
+
+  def setup
+    @default_options = Oj.default_options
+  end
+
+  def teardown
+    Oj.default_options = @default_options
+  end
 
   def test_nil
     handler = AllHandler.new()
@@ -233,7 +232,15 @@ class ScpTest < ::Test::Unit::TestCase
     begin
       Oj.sc_parse(handler, json)
     rescue Exception => e
-      assert_equal("unexpected character at line 1, column 6 [parse.c:637]", e.message)
+      assert_match(%r{unexpected character at line 1, column 6 \[(?:[a-z\.]+/)*parse\.c:\d+\]}, e.message)
+    end
+  end
+
+  def test_null_string
+    handler = AllHandler.new()
+    json = %{"\0"}
+    assert_raises Oj::ParseError do
+      Oj.sc_parse(handler, json)
     end
   end
 

data/test/test_strict.rb

@@ -1,33 +1,19 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
-# required. That can be set in the RUBYOPT environment variable.
-# export RUBYOPT=-w
+$: << File.dirname(__FILE__)
 
-$VERBOSE = true
+require 'helper'
 
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
+class StrictJuice < Minitest::Test
 
-require 'test/unit'
-require 'stringio'
-require 'date'
-require 'bigdecimal'
-require 'oj'
-
-$ruby = RUBY_DESCRIPTION.split(' ')[0]
-$ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
-
-def hash_eql(h1, h2)
-  return false if h1.size != h2.size
-  h1.keys.each do |k|
-    return false unless h1[k] == h2[k]
+  def setup
+    @default_options = Oj.default_options
   end
-  true
-end
 
-class StrictJuice < ::Test::Unit::TestCase
+  def teardown
+    Oj.default_options = @default_options
+  end
 
   def test_nil
     dump_and_load(nil, false)
@@ -175,7 +161,7 @@ class StrictJuice < ::Test::Unit::TestCase
   end
 
   def test_io_file
-    filename = 'open_file_test.json'
+    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
     File.open(filename, 'w') { |f| f.write(%{{
   "x":true,
   "y":58,