oj 2.9.0 → 2.9.1

data/test/struct.rb

@@ -0,0 +1,29 @@
+#!/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
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+A = Struct.new(:a,:b,:c,:d)
+B = Struct.new(:e,:f)
+
+obj = [A.new(55, B.new(1, 'X'), B.new(2, 'Y'), 3)]
+
+s = Oj.dump(obj, :mode => :object)
+
+100000.times do
+  Oj.load(s, :mode => :object)
+  # ds = Oj.dump(o, :mode => :object)
+  # if ds != s
+  #   puts ds
+  #   raise "holy crap"
+  # end
+end

data/test/test_file.rb

@@ -0,0 +1,242 @@
+#!/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
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'test/unit'
+require 'date'
+require 'bigdecimal'
+require 'oj'
+
+$ruby = RUBY_DESCRIPTION.split(' ')[0]
+$ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
+
+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
+
+class Range
+  def to_hash()
+    { 'begin' => self.begin, 'end' => self.end, 'exclude_end' => self.exclude_end? }
+  end
+end # Range
+
+class FileJuice < ::Test::Unit::TestCase
+
+  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
+    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(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)
+  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 }
+    dump_and_load(t, false)
+  end
+  def test_time_object_early
+    t = Time.xmlschema("1954-01-05T00:00:00.123456")
+    Oj.default_options = { :mode => :object }
+    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 }
+    obj = Jeez.new(true, 58)
+    json = Oj.dump(obj, :indent => 2)
+    assert(%{{"json_class":"Jeez","x":true,"y":58}
+} == json ||
+           %{{"json_class":"Jeez","y":58,"x":true}
+} == json)
+    dump_and_load(obj, false)
+    Oj.default_options = { :mode => :compat, :use_to_json => false }
+  end
+
+  def test_as_json_object_compat_hash
+    Oj.default_options = { :mode => :compat }
+    obj = Orange.new(true, 58)
+    json = Oj.dump(obj, :indent => 2)
+    assert(!json.nil?)
+    dump_and_load(obj, false)
+  end
+
+  # Range
+  def test_range_object
+    unless RUBY_VERSION.start_with?('1.8')
+      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
+  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.new('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.new('3.14159265358979323846'), false)
+    Oj.default_options = {:mode => mode}
+  end
+
+  def test_bigdecimal_object
+    mode = Oj.default_options[:mode]
+    Oj.default_options = {:mode => :object}
+    dump_and_load(BigDecimal.new('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_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)
+    assert_equal(obj, loaded)
+    loaded
+  end
+
+end

data/test/test_mimic.rb

@@ -80,19 +80,16 @@ class Mimic < ::Test::Unit::TestCase
     Oj.mimic_JSON # TBD
     children = []
     json = %{{"a":1,"b":[true,false]}}
-    if 'rubinius' == $ruby || 'jruby' == $ruby || '1.8.7' == RUBY_VERSION
+    if 'rubinius' == $ruby || '1.8.7' == RUBY_VERSION
       obj = JSON.load(json) {|x| children << x }
     else
       p = Proc.new {|x| children << x }
       obj = JSON.load(json, p)
     end
     assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-    # JRuby 1.7.0 rb_yield() is broken and converts the [true, falser] array into true
-    unless 'jruby' == $ruby && '1.9.3' == RUBY_VERSION
-      assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
-             [true, false, [true, false], 1, { 'a' => 1, 'b' => [true, false]}] == children,
-             "children don't match")
-    end
+    assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
+           [true, false, [true, false], 1, { 'a' => 1, 'b' => [true, false]}] == children,
+           "children don't match")
   end
 
 # []

data/test/test_strictx.rb

@@ -0,0 +1,58 @@
+#!/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
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'test/unit'
+require 'stringio'
+require 'date'
+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]
+  end
+  true
+end
+
+class StrictJuice < ::Test::Unit::TestCase
+
+  # Stream IO
+  def test_io_string
+    json = %{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}
+    input = StringIO.new(json)
+    obj = Oj.strict_loadx(input)
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+  def xtest_io_file
+    filename = 'open_file_test.json'
+    File.open(filename, 'w') { |f| f.write(%{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}) }
+    f = File.new(filename)
+    obj = Oj.strict_loadx(f)
+    f.close()
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+end

data/test/tests.rb

@@ -570,8 +570,10 @@ class Juice < ::Test::Unit::TestCase
     Oj.default_options = { :mode => :compat, :use_to_json => true }
     obj = Jeez.new(true, 58)
     json = Oj.dump(obj, :indent => 2)
-    assert(%{{"json_class":"Jeez","x":true,"y":58}} == json ||
-           %{{"json_class":"Jeez","y":58,"x":true}} == json)
+    assert(%{{"json_class":"Jeez","x":true,"y":58}
+} == json ||
+           %{{"json_class":"Jeez","y":58,"x":true}
+} == json)
     dump_and_load(obj, false)
     Oj.default_options = { :mode => :compat, :use_to_json => false }
   end
@@ -590,12 +592,14 @@ class Juice < ::Test::Unit::TestCase
   "^o":"Jeez",
   "x":true,
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "^o":"Jeez",
   "y":58,
   "x":true
-}} == json)
+}
+} == json)
     obj2 = Oj.load(json, :mode => :object)
     assert_equal(obj, obj2)
   end
@@ -629,12 +633,14 @@ class Juice < ::Test::Unit::TestCase
   "^o":"Jazz",
   "x":true,
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "^o":"Jazz",
   "y":58,
   "x":true
-}} == json)
+}
+} == json)
     obj2 = Oj.load(json, :mode => :object)
     assert_equal(obj, obj2)
   end
@@ -679,12 +685,14 @@ class Juice < ::Test::Unit::TestCase
   "^o":"Orange",
   "x":true,
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "^o":"Orange",
   "y":58,
   "x":true
-}} == json)
+}
+} == json)
     obj2 = Oj.load(json, :mode => :object)
     assert_equal(obj, obj2)
   end
@@ -711,11 +719,13 @@ class Juice < ::Test::Unit::TestCase
     assert(%{{
   "x":true,
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "y":58,
   "x":true
-}} == json)
+}
+} == json)
   end
   def test_object_object
     obj = Jam.new(true, 58)
@@ -724,12 +734,14 @@ class Juice < ::Test::Unit::TestCase
   "^o":"Jam",
   "x":true,
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "^o":"Jam",
   "y":58,
   "x":true
-}} == json)
+}
+} == json)
     obj2 = Oj.load(json, :mode => :object)
     assert_equal(obj, obj2)
   end
@@ -741,12 +753,14 @@ class Juice < ::Test::Unit::TestCase
   "^o":"Jam",
   "x":true,
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "^o":"Jam",
   "y":58,
   "x":true
-}} == json)
+}
+} == json)
     obj2 = Oj.load(json, :mode => :object, :class_cache => false)
     assert_equal(obj, obj2)
   end
@@ -969,13 +983,15 @@ class Juice < ::Test::Unit::TestCase
   "^i":1,
   "x":"^r1",
   "y":58
-}} == json ||
+}
+} == json ||
 %{{
   "^o":"Jam",
   "^i":1,
   "y":58,
   "x":"^r1"
-}} == json)
+}
+} == json)
     obj2 = Oj.load(json, :mode => :object, :circular => true)
     assert_equal(obj2.x.__id__, obj2.__id__)
   end
@@ -998,7 +1014,8 @@ class Juice < ::Test::Unit::TestCase
   "^i1",
   7,
   "^r1"
-]}, json)
+]
+}, json)
     a2 = Oj.load(json, :mode => :object, :circular => true)
     assert_equal(a2[1].__id__, a2.__id__)
   end