oj 2.18.5 → 3.16.11

data/test/test_saj.rb

@@ -1,186 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.dirname(__FILE__)
-
-require 'helper'
-
-$json = %{{
-  "array": [
-    {
-      "num"   : 3,
-      "string": "message",
-      "hash"  : {
-        "h2"  : {
-          "a" : [ 1, 2, 3 ]
-        }
-      }
-    }
-  ],
-  "boolean" : true
-}}
-
-class AllSaj < Oj::Saj
-  attr_accessor :calls
-
-  def initialize()
-    @calls = []
-  end
-
-  def hash_start(key)
-    @calls << [:hash_start, key]
-  end
-
-  def hash_end(key)
-    @calls << [:hash_end, key]
-  end
-
-  def array_start(key)
-    @calls << [:array_start, key]
-  end
-
-  def array_end(key)
-    @calls << [:array_end, key]
-  end
-
-  def add_value(value, key)
-    @calls << [:add_value, value, key]
-  end
-
-  def error(message, line, column)
-    @calls << [:error, message, line, column]
-  end
-
-end # AllSaj
-
-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}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, nil, nil]], handler.calls)
-  end
-
-  def test_true
-    handler = AllSaj.new()
-    json = %{true}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, true, nil]], handler.calls)
-  end
-
-  def test_false
-    handler = AllSaj.new()
-    json = %{false}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, false, nil]], handler.calls)
-  end
-
-  def test_string
-    handler = AllSaj.new()
-    json = %{"a string"}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, 'a string', nil]], handler.calls)
-  end
-
-  def test_fixnum
-    handler = AllSaj.new()
-    json = %{12345}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, 12345, nil]], handler.calls)
-  end
-
-  def test_float
-    handler = AllSaj.new()
-    json = %{12345.6789}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:add_value, 12345.6789, nil]], handler.calls)
-  end
-
-  def test_float_exp
-    handler = AllSaj.new()
-    json = %{12345.6789e7}
-    Oj.saj_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)
-  end
-
-  def test_array_empty
-    handler = AllSaj.new()
-    json = %{[]}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:array_start, nil],
-                  [:array_end, nil]], handler.calls)
-  end
-
-  def test_array
-    handler = AllSaj.new()
-    json = %{[true,false]}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:array_start, nil],
-                  [:add_value, true, nil],
-                  [:add_value, false, nil],
-                  [:array_end, nil]], handler.calls)
-  end
-
-  def test_hash_empty
-    handler = AllSaj.new()
-    json = %{{}}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:hash_start, nil],
-                  [:hash_end, nil]], handler.calls)
-  end
-
-  def test_hash
-    handler = AllSaj.new()
-    json = %{{"one":true,"two":false}}
-    Oj.saj_parse(handler, json)
-    assert_equal([[:hash_start, nil],
-                  [:add_value, true, 'one'],
-                  [:add_value, false, 'two'],
-                  [:hash_end, nil]], handler.calls)
-  end
-
-  def test_full
-    handler = AllSaj.new()
-    Oj.saj_parse(handler, $json)
-    assert_equal([[:hash_start, nil],
-                  [:array_start, 'array'],
-                  [:hash_start, nil],
-                  [:add_value, 3, 'num'],
-                  [:add_value, 'message', 'string'],
-                  [:hash_start, 'hash'],
-                  [:hash_start, 'h2'],
-                  [:array_start, 'a'],
-                  [:add_value, 1, nil],
-                  [:add_value, 2, nil],
-                  [:add_value, 3, nil],
-                  [:array_end, 'a'],
-                  [:hash_end, 'h2'],
-                  [:hash_end, 'hash'],
-                  [:hash_end, nil],
-                  [:array_end, 'array'],
-                  [:add_value, true, 'boolean'],
-                  [:hash_end, nil]], handler.calls)
-  end
-
-  def test_fixnum_bad
-    handler = AllSaj.new()
-    json = %{12345xyz}
-    Oj.saj_parse(handler, json)
-    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,396 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.dirname(__FILE__)
-
-require 'helper'
-require 'socket'
-
-$json = %{{
-  "array": [
-    {
-      "num"   : 3,
-      "string": "message",
-      "hash"  : {
-        "h2"  : {
-          "a" : [ 1, 2, 3 ]
-        }
-      }
-    }
-  ],
-  "boolean" : true
-}}
-
-class NoHandler < Oj::ScHandler
-  def initialize()
-  end
-end
-
-class AllHandler < Oj::ScHandler
-  attr_accessor :calls
-
-  def initialize()
-    @calls = []
-  end
-
-  def hash_start()
-    @calls << [:hash_start]
-    {}
-  end
-
-  def hash_end()
-    @calls << [:hash_end]
-  end
-
-  def hash_key(key)
-    @calls << [:hash_key, key]
-    return 'too' if 'two' == key
-    return :symbol if 'symbol' == key
-    key
-  end
-
-  def array_start()
-    @calls << [:array_start]
-    []
-  end
-
-  def array_end()
-    @calls << [:array_end]
-  end
-
-  def add_value(value)
-    @calls << [:add_value, value]
-  end
-
-  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 Closer < AllHandler
-  attr_accessor :io
-  def initialize(io)
-    super()
-    @io = io
-  end
-
-  def hash_start()
-    @calls << [:hash_start]
-    @io.close
-    {}
-  end
-
-  def hash_set(h, key, value)
-    @calls << [:hash_set, key, value]
-    @io.close
-  end
-
-end # Closer
-
-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()
-    json = %{null}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, nil]], handler.calls)
-  end
-
-  def test_true
-    handler = AllHandler.new()
-    json = %{true}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, true]], handler.calls)
-  end
-
-  def test_false
-    handler = AllHandler.new()
-    json = %{false}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, false]], handler.calls)
-  end
-
-  def test_string
-    handler = AllHandler.new()
-    json = %{"a string"}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, 'a string']], handler.calls)
-  end
-
-  def test_fixnum
-    handler = AllHandler.new()
-    json = %{12345}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:add_value, 12345]], 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)
-  end
-
-  def test_float_exp
-    handler = AllHandler.new()
-    json = %{12345.6789e7}
-    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)
-  end
-
-  def test_array_empty
-    handler = AllHandler.new()
-    json = %{[]}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:array_start],
-                  [:array_end],
-                  [:add_value, []]], handler.calls)
-  end
-
-  def test_array
-    handler = AllHandler.new()
-    json = %{[true,false]}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:array_start],
-                  [:array_append, true],
-                  [:array_append, false],
-                  [:array_end],
-                  [:add_value, []]], handler.calls)
-  end
-
-  def test_hash_empty
-    handler = AllHandler.new()
-    json = %{{}}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:hash_start],
-                  [:hash_end],
-                  [:add_value, {}]], handler.calls)
-  end
-
-  def test_hash
-    handler = AllHandler.new()
-    json = %{{"one":true,"two":false}}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:hash_start],
-                  [:hash_key, 'one'],
-                  [:hash_set, 'one', true],
-                  [:hash_key, 'two'],
-                  [:hash_set, 'too', false],
-                  [:hash_end],
-                  [:add_value, {}]], handler.calls)
-  end
-
-  def test_hash_sym
-    handler = AllHandler.new()
-    json = %{{"one":true,"two":false}}
-    Oj.sc_parse(handler, json, :symbol_keys => true)
-    assert_equal([[:hash_start],
-                  [:hash_key, 'one'],
-                  [:hash_set, 'one', true],
-                  [:hash_key, 'two'],
-                  [:hash_set, 'too', false],
-                  [:hash_end],
-                  [:add_value, {}]], handler.calls)
-  end
-
-  def test_symbol_hash_key_without_symbol_keys
-    handler = AllHandler.new()
-    json = %{{"one":true,"symbol":false}}
-    Oj.sc_parse(handler, json)
-    assert_equal([[:hash_start],
-                  [:hash_key, 'one'],
-                  [:hash_set, 'one', true],
-                  [:hash_key, 'symbol'],
-                  [:hash_set, :symbol, false],
-                  [:hash_end],
-                  [:add_value, {}]], handler.calls)
-  end
-
-  def test_full
-    handler = AllHandler.new()
-    Oj.sc_parse(handler, $json)
-    assert_equal([[:hash_start],
-                  [:hash_key, 'array'],
-                  [:array_start],
-                  [:hash_start],
-                  [:hash_key, 'num'],
-                  [:hash_set, "num", 3],
-                  [:hash_key, 'string'],
-                  [:hash_set, "string", "message"],
-                  [:hash_key, 'hash'],
-                  [:hash_start],
-                  [:hash_key, 'h2'],
-                  [:hash_start],
-                  [:hash_key, 'a'],
-                  [:array_start],
-                  [:array_append, 1],
-                  [:array_append, 2],
-                  [:array_append, 3],
-                  [:array_end],
-                  [:hash_set, "a", []],
-                  [:hash_end],
-                  [:hash_set, "h2", {}],
-                  [:hash_end],
-                  [:hash_set, "hash", {}],
-                  [:hash_end],
-                  [:array_append, {}],
-                  [:array_end],
-                  [:hash_set, "array", []],
-                  [:hash_key, 'boolean'],
-                  [:hash_set, "boolean", true],
-                  [:hash_end],
-                  [:add_value, {}]], handler.calls)
-  end
-
-  def test_double
-    handler = AllHandler.new()
-    json = %{{"one":true,"two":false}{"three":true,"four":false}}
-    Oj.sc_parse(handler, json) { |j| j }
-    assert_equal([[:hash_start],
-                  [:hash_key, 'one'],
-                  [:hash_set, 'one', true],
-                  [:hash_key, 'two'],
-                  [:hash_set, 'too', false],
-                  [:hash_end],
-                  [:add_value, {}],
-                  [:hash_start],
-                  [:hash_key, 'three'],
-                  [:hash_set, 'three', true],
-                  [:hash_key, 'four'],
-                  [:hash_set, 'four', false],
-                  [:hash_end],
-                  [:add_value, {}]], handler.calls)
-  end
-
-  def test_none
-    handler = NoHandler.new()
-    Oj.sc_parse(handler, $json)
-  end
-
-  def test_fixnum_bad
-    handler = AllHandler.new()
-    json = %{12345xyz}
-    assert_raises Oj::ParseError do
-      Oj.sc_parse(handler, json)
-    end
-  end
-
-  def test_null_string
-    handler = AllHandler.new()
-    json = %{"\0"}
-    assert_raises Oj::ParseError do
-      Oj.sc_parse(handler, json)
-    end
-  end
-
-  def test_pipe
-    handler = AllHandler.new()
-    json = %{{"one":true,"two":false}}
-    IO.pipe do |read_io, write_io|
-      if fork
-        write_io.close
-        Oj.sc_parse(handler, read_io) {|v| p v}
-        read_io.close
-        assert_equal([[:hash_start],
-                      [:hash_key, 'one'],
-                      [:hash_set, 'one', true],
-                      [:hash_key, 'two'],
-                      [:hash_set, 'too', false],
-                      [:hash_end],
-                      [:add_value, {}]], handler.calls)
-      else
-        read_io.close
-        write_io.write json
-        write_io.close
-        Process.exit(0)
-      end
-    end
-  end
-
-  def test_pipe_close
-    json = %{{"one":true,"two":false}}
-    IO.pipe do |read_io, write_io|
-      if fork
-        write_io.close
-        handler = Closer.new(read_io)
-        err = nil
-        begin
-          Oj.sc_parse(handler, read_io)
-          read_io.close
-        rescue Exception => e
-          err = e.class.to_s
-        end
-        assert_equal("IOError", err)
-        assert_equal([[:hash_start],
-                      [:hash_key, 'one'],
-                      [:hash_set, 'one', true]], handler.calls)
-      else
-        read_io.close
-        write_io.write json[0..11]
-        sleep(0.1)
-        begin
-          write_io.write json[12..-1]
-        rescue Exception => e
-          # ignore, should fail to write
-        end
-        write_io.close
-        Process.exit(0)
-      end
-    end
-  end
-
-  def test_socket_close
-    json = %{{"one":true,"two":false}}
-    begin
-      server = TCPServer.new(8080)
-    rescue
-      # Not able to open a socket to run the test. Might be Travis.
-      return
-    end
-    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.close
-      end
-    end
-    begin
-      sock = TCPSocket.new('localhost', 8080)
-    rescue
-      # Not able to open a socket to run the test. Might be Travis.
-      return
-    end
-    handler = Closer.new(sock)
-    err = nil
-    begin
-      Oj.sc_parse(handler, sock)
-    rescue Exception => e
-      err = e.class.to_s
-    end
-    assert_equal("IOError", err)
-    assert_equal([[:hash_start],
-                  [:hash_key, 'one'],
-                  [:hash_set, 'one', true]], handler.calls)
-  end
-
-end

data/test/test_serializer.rb

@@ -1,59 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.dirname(__FILE__)
-
-%w(lib ext test).each do |dir|
-  $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
-end
-
-require 'minitest'
-require 'minitest/autorun'
-require 'oj'
-
-Oj.mimic_JSON
-
-require 'rails/all'
-require 'active_model'
-require 'active_model_serializers'
-require 'active_support/json'
-
-#Oj.mimic_JSON
-
-class Category
-  include ActiveModel::Model
-  include ActiveModel::SerializerSupport
-
-  attr_accessor :id, :name
-
-  def initialize(id, name)
-    @id   = id
-    @name = name
-  end
-end
-
-class CategorySerializer < ActiveModel::Serializer
-  attributes :id, :name
-end
-
-class MimicRails < Minitest::Test
-
-  def test_dump_object
-    Oj.default_options= {:indent => 0}
-    category = Category.new(1, 'test')
-    serializer = CategorySerializer.new(category)
-
-    json = serializer.to_json()
-    puts "*** serializer.to_json() #{serializer.to_json()}"
-    assert_equal(%|{"category":{"id":1,"name":"test"}}|, json)
-
-    json = serializer.as_json()
-    puts "*** serializer.as_json() #{serializer.as_json()}"
-    assert_equal({"category" => {:id => 1, :name => "test"}}, json)
-
-    json = JSON.dump(serializer)
-    puts "*** JSON.dump(serializer) #{JSON.dump(serializer)}"
-    assert_equal(%|{"category":{"id":1,"name":"test"}}|, json)
-  end
-
-end # MimicRails