oj 2.9.4 → 2.9.5

data/test/perf_str.rb

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby -wW1
-
-$: << '.'
-$: << '../lib'
-$: << '../ext'
-
-if __FILE__ == $0
-  if (i = ARGV.index('-I'))
-    x,path = ARGV.slice!(i, 2)
-    $: << path
-  end
-end
-
-require 'optparse'
-require 'ox'
-require 'oj'
-require 'perf'
-
-$indent = 0
-$iter = 1000
-
-opts = OptionParser.new
-
-opts.on("-i", "--iterations [Int]", Integer, "iterations")  { |i| $iter = i }
-opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
-files = opts.parse(ARGV)
-
-$obj = "x" * 50_000
-
-Oj.default_options = { :mode => :strict, :indent => $indent }
-
-puts '-' * 80
-puts "Dump Performance"
-perf = Perf.new()
-perf.add('Oj', 'dump') { Oj.dump($obj) }
-perf.add('Ox', 'dump') { Ox.dump($obj, :indent => $indent, :circular => $circular) }
-perf.add('Marshal', 'dump') { Marshal.dump($obj) }
-perf.run($iter)

data/test/perf_strictx.rb

@@ -1,97 +0,0 @@
-#!/usr/bin/env ruby -wW1
-# encoding: UTF-8
-
-$: << '.'
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
-
-require 'stringio'
-require 'optparse'
-require 'perf'
-require 'oj'
-
-$verbose = false
-$indent = 0
-$iter = 20000
-$with_bignum = false
-$with_nums = true
-$size = 0
-
-opts = OptionParser.new
-opts.on("-v", "verbose")                                    { $verbose = true }
-opts.on("-c", "--count [Int]", Integer, "iterations")       { |i| $iter = i }
-opts.on("-i", "--indent [Int]", Integer, "indentation")     { |i| $indent = i }
-opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")    { |i| $size = i }
-opts.on("-b", "with bignum")                                { $with_bignum = true }
-opts.on("-n", "without numbers")                            { $with_nums = false }
-opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
-files = opts.parse(ARGV)
-
-if $with_nums
-  $obj = {
-    'a' => 'Alpha', # string
-    'b' => true,    # boolean
-    'c' => 12345,   # number
-    'd' => [ true, [false, [-123456789, 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
-    'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
-  }
-  $obj['g'] = 12345678901234567890123456789 if $with_bignum
-else
-  $obj = {
-    'a' => 'Alpha',
-    'b' => true,
-    'c' => '12345',
-    'd' => [ true, [false, ['12345', nil], '3.967', ['something', false], nil]],
-    'e' => { 'zero' => '0', 'one' => '1', 'two' => '2' },
-    'f' => nil,
-    'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
-    'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
-  }
-end
-
-Oj.default_options = { :indent => $indent, :mode => :strict }
-
-if 0 < $size
-  o = $obj
-  $obj = []
-  (4 * $size).times do
-    $obj << o
-  end
-end
-
-$json = Oj.dump($obj)
-$obj_json = Oj.dump($obj, :mode => :object)
-#puts "*** size: #{$obj_json.size}"
-$failed = {} # key is same as String used in tests later
-
-def capture_error(tag, orig, load_key, dump_key, &blk)
-  begin
-    obj = blk.call(orig)
-    raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
-  rescue Exception => e
-    $failed[tag] = "#{e.class}: #{e.message}"
-  end
-end
-
-# Verify that all packages dump and load correctly and return the same Object as the original.
-capture_error('Oj:strict-str', $obj, 'load', 'dump') { |o| Oj.strict_load(Oj.dump(o, :mode => :strict)) }
-capture_error('Oj:strict', $obj, 'load', 'dump') { |o| Oj.strict_load(StringIO.new(Oj.dump(o, :mode => :strict))) }
-
-puts '-' * 80
-puts "Strict Parse Performance"
-perf = Perf.new()
-perf.add('Oj:strict-str', 'strict_load-str') { Oj.strict_load($json) }
-perf.add('Oj:strict-io', 'strict_load') { Oj.strict_load(StringIO.new($json)) }
-perf.run($iter)
-
-puts
-puts '-' * 80
-puts
-
-unless $failed.empty?
-  puts "The following packages were not included for the reason listed"
-  $failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
-end

data/test/test_mimic_after.rb

@@ -1,35 +0,0 @@
-#!/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 'oj'
-require 'json'
-
-class MimicAfter < ::Test::Unit::TestCase
-
-  def test0_mimic_json
-    assert(!defined?(JSON).nil?)
-    Oj.mimic_JSON
-  end
-
-# dump
-  def test_dump_string
-    Oj.default_options= {:indent => 2} # JSON this will not change anything
-    json = JSON.dump([1, true, nil])
-    assert_equal(%{[
-  1,
-  true,
-  null]}, json)
-  end
-
-end # MimicAfter

data/test/test_strictx.rb

@@ -1,58 +0,0 @@
-#!/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/write_fake_log.rb

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby -wW1
-
-$: << '.'
-$: << '../lib'
-$: << '../ext'
-
-if __FILE__ == $0
-  if (i = ARGV.index('-I'))
-    x,path = ARGV.slice!(i, 2)
-    $: << path
-  end
-end
-
-require 'optparse'
-require 'oj'
-require 'perf'
-
-$indent = 0
-$iter = 1
-
-opts = OptionParser.new
-
-opts.on("-c", "--count [Int]", Integer, "iterations")       { |i| $iter = i }
-opts.on("-i", "--indent [Int]", Integer, "indent")          { |i| $indent = i }
-
-opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
-files = opts.parse(ARGV)
-
-$levels = [ "ERROR", "WARN", "INFO", "DEBUG", "TRACE" ]
-$entry = {
-  "bar" => "0",
-  "level" => "INFO",
-  "message" => "A message",
-  "msgType" => 1,
-  "source" => "Test",
-  "thread" => "main",
-  "version" => 1,
-  "when" => 1400000000000000000,
-}
-
-Oj.default_options = { :mode => :strict, :indent => $indent }
-
-filename = 'log.json'
-File.open(filename, "w") { |f|
-  $iter.times do |i|
-    $entry["bar"] = (1_400_000_000_000 + i * 200) / 1000
-    $entry["when"] = 1_400_000_000_000_000_000 + i * 100_000_000
-    $entry["message"] = "This is log message number #{i} out of #{$iter} entries."
-    $entry["level"] = $levels[i % $levels.size]
-    Oj.to_stream(f, $entry, :indent => $indent)
-    if 0 == $indent
-      f.flush()
-      f.write("\n")
-    end
-  end
-}
-
-$cnt = 0
-perf = Perf.new()
-perf.add('Oj.load_file', '') { Oj.load_file(filename) { |o| $cnt += 1 } }
-perf.run(1)
-
-puts "*** read #{$cnt} entries"

data/test/x.rb

@@ -1,59 +0,0 @@
-#!/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'
-
-# Oj is not able to deserialize all classes that are a subclass of a Ruby
-# Exception. Only exception that take one required string argument in the
-# initialize() method are supported. This is an example of how to write an
-# Exception subclass that supports both a single string intializer and an
-# Exception as an argument. Additional optional arguments can be added as well.
-#
-# The reason for this restriction has to do with a design decision on the part
-# of the Ruby developers. Exceptions are special Objects. They do not follow the
-# rules of other Objects. Exceptions have 'mesg' and a 'bt' attribute. Note that
-# these are not '@mesg' and '@bt'. They can not be set using the normal C or
-# Ruby calls. The only way I have found to set the 'mesg' attribute is through
-# the initializer. Unfortunately that means any subclass that provides a
-# different initializer can not be automatically decoded. A way around this is
-# to use a create function but this example shows an alternative.
-
-class WrapException < StandardError
-  attr_reader :original
-
-  def initialize(msg_or_err)
-    if msg_or_err.is_a?(Exception)
-      super(msg_or_err.message)
-      @original = msg_or_err
-      set_backtrace(msg_or_err.backtrace)
-    else
-      super(message)
-      @original = nil
-    end
-  end
-end
-
-e = WrapException.new(RuntimeError.new("Something broke."))
-
-json = Oj.dump(e, :mode => :object)
-puts "original:\n#{json}"
-# outputs:
-# original:
-# {"^o":"WrapException","original":{"^o":"RuntimeError","~mesg":"Something broke.","~bt":null},"~mesg":"Something broke.","~bt":null}
-
-e2 = Oj.load(json, :mode => :object)
-puts "dumped, loaded, and dumped again:\n#{Oj.dump(e2, :mode => :object)}"
-# outputs:
-# original: {"^o":"WrapException","original":{"^o":"RuntimeError","~mesg":"Something broke.","~bt":null},"~mesg":"Something broke.","~bt":null}
-# dumped, loaded, and dumped again:
-# {"^o":"WrapException","original":{"^o":"RuntimeError","~mesg":"Something broke.","~bt":null},"~mesg":"Something broke.","~bt":null}
-