jrjackson 0.3.9-java

data/src/main/java/com/jrjackson/SajParse.java

@@ -0,0 +1,169 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonStreamContext;
+import com.fasterxml.jackson.core.JsonLocation;
+
+import java.io.IOException;
+
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class SajParse extends StreamParse {
+    
+    protected DynamicMethod _error;
+    protected boolean _no_error;
+
+    public SajParse(ThreadContext ctx, IRubyObject handler)
+            throws RaiseException {
+        super(ctx, handler);
+        
+        if (_no_add_value) {
+            throw ParseError.newParseError(_ruby, "Handler does not implement public API");
+        }        
+        _error = _meta.searchMethod("error");
+        _no_error = _error.isUndefined();
+    
+    }
+    
+    @Override
+    public IRubyObject deserialize(JsonParser jp) {
+
+        try {
+            while(jp.nextValue() != null) {
+                handleCurrentToken(jp);
+            }
+        }
+        catch (JsonProcessingException e) {
+            if(!_no_error) {
+                JsonLocation location = e.getLocation();
+                IRubyObject message = RubyUtils.rubyString(_ruby, e.getMessage());
+                IRubyObject line = RubyUtils.rubyFixnum(_ruby, location.getLineNr());
+                IRubyObject column = RubyUtils.rubyFixnum(_ruby, location.getColumnNr());
+                
+                _error.call(_ctx, _handler, _meta, "error", message, line, column);
+            }
+        }
+        catch (IOException e) {
+            if(!_no_error) {
+                IRubyObject message = RubyUtils.rubyString(_ruby, e.getMessage());
+                IRubyObject line = RubyUtils.rubyFixnum(_ruby, 1);
+                IRubyObject column = RubyUtils.rubyFixnum(_ruby, 1);
+                
+                _error.call(_ctx, _handler, _meta, "error", message, line, column);
+            }
+        }
+
+        return _ctx.nil;
+    }
+    
+    private void callAddValue(IRubyObject val, IRubyObject key) {
+        _add_value.call(_ctx, _handler, _meta, "add_value", val, key);
+    }
+    
+    private IRubyObject getParentName(JsonStreamContext x) {
+        String parentName = x.getCurrentName();
+        IRubyObject parent = _ctx.nil;
+        
+        if (!x.inRoot()) {
+            parentName = x.getParent().getCurrentName();
+        }
+        if (parentName != null) {
+            parent = RubyUtils.rubyString(_ruby, parentName);
+        }
+        return parent;
+    }
+    
+    private IRubyObject getFieldName(JsonStreamContext x) {
+        String currentName = x.getCurrentName();
+        IRubyObject name = _ctx.nil;
+
+        if (currentName != null) {
+            name = RubyUtils.rubyString(_ruby, currentName);
+        }
+        return name;
+    }
+    
+    private void handleCurrentToken(JsonParser jp)
+            throws IOException, JsonProcessingException {
+        
+        JsonStreamContext cx = jp.getParsingContext();
+  
+        IRubyObject value;
+        
+        switch (jp.getCurrentToken()) {
+            case START_OBJECT:
+                if (!_no_hash_start) {
+                    _hash_start.call(_ctx, _handler, _meta, "hash_start", getParentName(cx));
+                }
+                break;
+                
+            case START_ARRAY:
+                if (!_no_array_start) {
+                    _array_start.call(_ctx, _handler, _meta, "array_start", getParentName(cx));
+                }
+                break;
+
+            case FIELD_NAME:
+                break;
+                
+            case VALUE_EMBEDDED_OBJECT:
+                value = RubyUtils.rubyObject(_ruby, jp.getEmbeddedObject());
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_STRING:
+                value = keyConverter.convert(_ruby, jp);
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_NUMBER_INT:
+                /* [JACKSON-100]: caller may want to get all integral values
+                * returned as BigInteger, for consistency
+                */
+                JsonParser.NumberType numberType = jp.getNumberType();
+                value = RubyUtils.rubyBignum(_ruby, jp.getBigIntegerValue());
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_NUMBER_FLOAT:
+                value = RubyUtils.rubyBigDecimal(_ruby, jp.getDecimalValue());
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_TRUE:
+                value = _ruby.newBoolean(Boolean.TRUE);
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_FALSE:
+                value = _ruby.newBoolean(Boolean.FALSE);
+                callAddValue(value, getFieldName(cx));
+                break;
+                
+            case VALUE_NULL: // should not get this but...
+                value = _ctx.nil;
+                callAddValue(value, getFieldName(cx));
+                break;
+               
+            case END_ARRAY:
+                if (!_no_array_end) {
+                    _array_end.call(_ctx, _handler, _meta, "array_end", getFieldName(cx));
+                }
+                break;
+                
+            case END_OBJECT:
+                if (!_no_hash_end) {
+                    _hash_end.call(_ctx, _handler, _meta, "hash_end", getFieldName(cx));
+                }
+                break;
+        }
+    }
+}

data/src/main/java/com/jrjackson/SchParse.java

@@ -0,0 +1,209 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonStreamContext;
+import java.io.IOException;
+import java.util.HashMap;
+
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.RubyString;
+import org.jruby.exceptions.RaiseException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public class SchParse  extends StreamParse {
+
+    protected final DynamicMethod _hash_key;
+    protected final boolean _no_hash_key;
+    
+    protected final DynamicMethod _hash_set;
+    protected final boolean _no_hash_set;
+    
+    protected final DynamicMethod _array_append;
+    protected final boolean _no_array_append;
+    
+    protected final HashMap<JsonStreamContext, IRubyObject> _objectMap = new HashMap<JsonStreamContext, IRubyObject>();
+    protected JsonStreamContext _deepestContext;
+    
+    public SchParse(ThreadContext ctx, IRubyObject handler)
+            throws RaiseException {
+        super(ctx, handler);
+        
+        _hash_key = _meta.searchMethod("hash_key");
+        _no_hash_key = _hash_key.isUndefined();
+        
+        _hash_set = _meta.searchMethod("hash_set");
+        _no_hash_set = _hash_set.isUndefined();
+
+        _array_append = _meta.searchMethod("array_append");
+        _no_array_append = _array_append.isUndefined();
+        
+        //_hash_key is optional
+        if (
+            _no_hash_start || _no_hash_end ||
+            _no_array_start || _no_array_end ||
+            _no_add_value || _no_hash_set || _no_array_append
+        ) {
+            throw ParseError.newParseError(_ruby, "Handler does not implement public API");
+        }
+    }
+
+    @Override
+    public IRubyObject deserialize(JsonParser jp) throws RaiseException {
+        try {
+            
+            while (jp.nextValue() != null) {
+                handleCurrentToken(jp);
+            }
+            return _ctx.nil;
+            
+        } catch (JsonProcessingException e) {
+            throw ParseError.newParseError(_ruby, e.getLocalizedMessage());
+        } catch (IOException e) {
+            throw _ruby.newIOError(e.getLocalizedMessage());
+        }
+    }
+
+    private void callAddValue(JsonStreamContext x) {
+        JsonStreamContext px = x.getParent();
+        IRubyObject target = _objectMap.get(x);
+        IRubyObject dtarget = _objectMap.get(_deepestContext);
+
+        if (px == null) {
+            _add_value.call(_ctx, _handler, _meta, "add_value", dtarget);
+            return;
+        }
+        
+        if (x.inArray()) {
+            _array_append.call(_ctx, _handler, _meta, "array_append", target, dtarget);
+        } else if (x.inObject()) {
+            IRubyObject treatedKey = callHashKey(x);
+            _hash_set.call(_ctx, _handler, _meta, "hash_set", target, treatedKey, dtarget);
+        } else {
+            _add_value.call(_ctx, _handler, _meta, "add_value", target);
+        }
+    }
+
+    private void callAddValue(JsonStreamContext x, IRubyObject val) {
+        IRubyObject target = _objectMap.get(x);
+
+        if (x.inArray()) {
+            _array_append.call(_ctx, _handler, _meta, "array_append", target, val);
+        } else if (x.inObject()) {
+            IRubyObject treatedKey = callHashKey(x);
+            _hash_set.call(_ctx, _handler, _meta, "hash_set", target, treatedKey, val);
+        } else {
+            _add_value.call(_ctx, _handler, _meta, "add_value", val);
+        }
+    }
+    
+    private IRubyObject callHashKey(JsonStreamContext x) {
+        String k = x.getCurrentName();
+        if (k == null) {
+            return _ctx.nil;
+        }
+        RubyString key =  RubyUtils.rubyString(_ruby, k);
+        if (_no_hash_key) {
+            return key;
+        }
+        return _hash_key.call(_ctx, _handler, _meta, "hash_key", key);
+    }
+
+    private void handleCurrentToken(JsonParser jp)
+            throws IOException, JsonProcessingException {
+        
+        JsonStreamContext cx = jp.getParsingContext();
+        IRubyObject value;
+        IRubyObject rubyObject;
+
+        switch (jp.getCurrentToken()) {
+            case START_OBJECT:
+                _deepestContext = cx;
+                rubyObject = _hash_start.call(_ctx, _handler, _meta, "hash_start");
+                _objectMap.put(cx, rubyObject);
+                break;
+
+            case START_ARRAY:
+                _deepestContext = cx;
+                rubyObject = _array_start.call(_ctx, _handler, _meta, "array_start");
+                _objectMap.put(cx, rubyObject);
+                break;
+
+            case FIELD_NAME:
+                break;
+
+            case VALUE_EMBEDDED_OBJECT:
+                value = RubyUtils.rubyObject(_ruby, jp.getEmbeddedObject());
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_STRING:
+                value = keyConverter.convert(_ruby, jp);
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_NUMBER_INT:
+                /* [JACKSON-100]: caller may want to get all integral values
+                 * returned as BigInteger, for consistency
+                 */
+                JsonParser.NumberType numberType = jp.getNumberType();
+                value = RubyUtils.rubyBignum(_ruby, jp.getBigIntegerValue());
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_NUMBER_FLOAT:
+                value = RubyUtils.rubyBigDecimal(_ruby, jp.getDecimalValue());
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_TRUE:
+                value = _ruby.newBoolean(Boolean.TRUE);
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_FALSE:
+                value = _ruby.newBoolean(Boolean.FALSE);
+                callAddValue(cx, value);
+                break;
+
+            case VALUE_NULL: // should not get this but...
+                value = _ctx.nil;
+                callAddValue(cx, value);
+                break;
+
+            case END_ARRAY:
+                _array_end.call(_ctx, _handler, _meta, "array_end");
+                callAddValue(cx);
+                _deepestContext = cx;
+                break;
+
+            case END_OBJECT:
+                _hash_end.call(_ctx, _handler, _meta, "hash_end");
+                callAddValue(cx);
+                _deepestContext = cx;
+                break;
+        }
+        
+    }
+    
+}
+//        System.out.println("--- callAddValue final ---");
+//        if (px != null) {
+//            System.out.println("-------- parent --------");
+//            System.out.println(px.getTypeDesc());
+//            System.out.println(px.getCurrentName());
+//        }
+//        System.out.println("-------- current --------");
+//        System.out.println(x.getTypeDesc());
+//        System.out.println(x.getCurrentName());
+//        System.out.println(target);
+//        
+//        System.out.println("-------- deepest --------");
+//        System.out.println(_deepestContext.getTypeDesc());
+//        System.out.println(_deepestContext.getCurrentName());
+//        System.out.println(dtarget);

data/src/main/java/com/jrjackson/StreamParse.java

@@ -0,0 +1,66 @@
+package com.jrjackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+
+/**
+ *
+ * @author Guy Boertje
+ */
+public abstract class StreamParse {
+
+    protected final ThreadContext _ctx;
+    protected final Ruby _ruby;
+    protected final IRubyObject _handler;
+    protected final RubyClass _meta;
+    protected final RubyStringConverter keyConverter = new RubyStringConverter();
+    
+    protected final DynamicMethod _hash_start;
+    protected final boolean _no_hash_start;
+
+    protected final DynamicMethod _hash_end;
+    protected final boolean _no_hash_end;
+
+    protected final DynamicMethod _array_start;
+    protected final boolean _no_array_start;
+
+    protected final DynamicMethod _array_end;
+    protected final boolean _no_array_end;
+    
+    protected final DynamicMethod _add_value;
+    protected final boolean _no_add_value;
+
+    public StreamParse(ThreadContext ctx, IRubyObject handler)
+            throws RaiseException {
+
+        _ctx = ctx;
+        _ruby = ctx.runtime;
+        _handler = handler;
+        _meta = _handler.getMetaClass();
+        
+        _add_value = _meta.searchMethod("add_value");
+        _no_add_value = _add_value.isUndefined();
+
+        _hash_start = _meta.searchMethod("hash_start");
+        _no_hash_start = _hash_start.isUndefined();
+
+        _hash_end = _meta.searchMethod("hash_end");
+        _no_hash_end = _hash_end.isUndefined();
+
+        _array_start = _meta.searchMethod("array_start");
+        _no_array_start = _array_start.isUndefined();
+
+        _array_end = _meta.searchMethod("array_end");
+        _no_array_end = _array_end.isUndefined();
+
+    }
+    
+    public abstract IRubyObject deserialize(JsonParser jp) 
+            throws RaiseException;
+}

data/test/jrjackson_test.rb

@@ -0,0 +1,533 @@
+# encoding: UTF-8
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require "java"
+
+require 'securerandom'
+
+require 'test/unit'
+require 'thread'
+require 'bigdecimal'
+require 'jrjackson'
+require 'stringio'
+require 'time'
+require 'date'
+
+class JrJacksonTest < Test::Unit::TestCase
+#   def test_serialize_date
+#     # default date format
+#     time_string = "2014-12-18 18:18:18 +0000"
+#     source_time = Time.parse(time_string)
+#     # source_time = Date.today
+#     serialized_output = JrJackson::Json.dump({current_time: source_time})
+#     assert_equal %Q{{"current_time":"#{time_string}"}}, serialized_output
+#   end
+# end
+  class Test::Unit::CustomObj
+  end
+
+  class ToJsonData
+    attr_reader :one, :two, :six
+    def initialize(a,b,c)
+      @one, @two, @six = a,b,c
+    end
+    def to_h
+      {'one' => one, 'two' => two, 'six' => six}
+    end
+    def to_json_data
+      [one, two, six]
+    end
+  end
+
+  class CustomToH
+    attr_accessor :one, :two, :six
+    def initialize(a,b,c)
+      @one, @two, @six = a,b,c
+    end
+    def to_h
+      {'one' => one, 'two' => two, 'six' => six}
+    end
+  end
+
+  class CustomToHash
+    attr_accessor :one, :two, :six
+    def initialize(a,b,c)
+      @one, @two, @six = a,b,c
+    end
+    def to_hash
+      {'one' => one, 'two' => two, 'six' => six}
+    end
+  end
+
+  class CustomToJson
+    attr_accessor :one, :two, :six
+    def initialize(a,b,c)
+      @one, @two, @six = a,b,c
+    end
+    def to_json
+      %Q|{"one":#{one},"two":#{two},"six":#{six}}|
+    end
+  end
+
+  class CustomToTime
+    def initialize(tm = Time.now)
+      @now = tm
+    end
+    def to_time
+      @now.to_time
+    end
+  end
+
+  CustomStruct = Struct.new(:one, :two, :six)
+
+
+  class ScHandler
+    attr_accessor :calls
+
+    def initialize(arr = [])
+      @calls = arr
+    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)
+      # h[key] = value
+      @calls << [:hash_set, key, value]
+    end
+
+    def array_append(a, value)
+      # a.push(value)
+      @calls << [:array_append, value]
+    end
+  end
+
+  JsonString = %Q|{
+    "array": [
+      {
+        "num"   : 3,
+        "string": "message",
+        "hash"  : {
+          "h2"  : {
+            "a" : [ 1, 2, 3 ]
+          }
+        }
+      }
+    ],
+    "boolean" : true
+  }|
+
+  def test_sc_parse
+    array = []
+    handler = ScHandler.new(array)
+    JrJackson::Json.sc_load(handler, JsonString)
+    assert_equal(
+      [
+        [:hash_start],
+        [:array_start],
+        [:hash_start],
+        [:hash_key, 'num'],
+        [:hash_set, "num", 3],
+        [:hash_key, 'string'],
+        [:hash_set, "string", "message"],
+        [:hash_start],
+        [:hash_start],
+        [:array_start],
+        [:array_append, 1],
+        [:array_append, 2],
+        [:array_append, 3],
+        [:array_end],
+        [:hash_key, "a"],
+        [:hash_set, "a", []],
+        [:hash_end],
+        [:hash_key, "h2"],
+        [:hash_set, "h2", {}],
+        [:hash_end],
+        [:hash_key, "hash"],
+        [:hash_set, "hash", {}],
+        [:hash_end],
+        [:array_append, {}],
+        [:array_end],
+        [:hash_key, "array"],
+        [:hash_set, "array", []],
+        [:hash_key, 'boolean'],
+        [:hash_set, "boolean", true],
+        [:hash_end],
+        [:add_value, {}]
+      ],
+    handler.calls
+  )
+  end
+
+  class SjHandler
+    attr_reader :calls
+    def initialize(arr = []) @calls = arr; 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
+
+  def test_sj_parse
+    handler = SjHandler.new()
+    JrJackson::Json.sj_load(handler, JsonString)
+    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_to_json_data
+    object = ToJsonData.new("uno", :two, 6.0)
+    expected = "[1,[\"uno\",\"two\",6.0]]"
+    actual = JrJackson::Json.dump([1, object])
+    assert_equal expected, actual
+  end
+
+  def test_datetime
+    h = {datetime: DateTime.parse("2014-01-27T18:24:46+01:00")}
+    expected = '{"datetime":"2014-01-27 17:24:46 +0000"}'
+    actual = JrJackson::Json.dump(h)
+    assert_equal expected, actual
+  end
+
+  def test_dump_date_in_array
+    expected = "[\"2016-04-10\"]"
+    td = Date.new(2016, 4, 10)
+    actual = JrJackson::Json.generate([td])
+    assert_equal(actual, expected)
+  end
+
+  def test_threading
+    q1, q2, q3 = Queue.new, Queue.new, Queue.new
+
+    s1 = %Q|{"a":2.5, "b":0.214, "c":3.4567, "d":-3.4567}|
+    th1 = Thread.new(s1) do |string|
+      q1 << JrJackson::Json.load(string, {use_bigdecimal: true, raw: true})
+    end
+    th2 = Thread.new(s1) do |string|
+      q2 << JrJackson::Json.load(string, {use_bigdecimal: true, symbolize_keys: true})
+    end
+    th3 = Thread.new(s1) do |string|
+      q3 << JrJackson::Json.load(string, {use_bigdecimal: false, symbolize_keys: true})
+    end
+    a1, a2, a3 = q1.pop, q2.pop, q3.pop
+    assert_equal ["a", "b", "c", "d"], a1.keys
+    assert a1.values.all? {|v| v.is_a?(Java::JavaMath::BigDecimal)}, "Expected all values to be Java::JavaMath::BigDecimal"
+    assert_equal [:a, :b, :c, :d], a2.keys
+    assert a2.values.all? {|v| v.is_a?(BigDecimal)}, "Expected all values to be BigDecimal"
+    assert a3.values.all? {|v| v.is_a?(Float)}, "Expected all values to be Float"
+  end
+
+  def test_deserialize_JSON_with_UTF8_characters
+    json_string = JrJackson::Json.dump({"utf8" => "żółć"})
+    expected = {utf8: "żółć"}
+    actual = JrJackson::Json.load(json_string, :symbolize_keys => true)
+
+    assert_equal expected, actual
+  end
+
+  def test_deserialize_JSON_with_two_entries
+    json_string = JrJackson::Json.dump({'foo' => 'foo_value', 'bar' => 'bar_value'})
+    expected = {foo: 'foo_value', bar: 'bar_value'}
+    actual = JrJackson::Json.load(json_string, :symbolize_keys => true)
+    assert_equal expected, actual
+  end
+
+  def test_serialize_non_json_datatypes_as_values
+    dt = Time.now
+    today = Date.today
+    co1 = CustomToH.new("uno", :two, 6.0)
+    co2 = CustomToHash.new("uno", :two, 6.0)
+    co3 = CustomToJson.new(1.0, 2, 6.0)
+    co4 = CustomStruct.new(1, 2, 6)
+    co5 = CustomToTime.new(today)
+    source = {'sym' => :a_symbol, 'dt' => dt, 'co1' => co1, 'co2' => co2, 'co3' => co3, 'co4' => co4, 'co5' => co5}
+    json_string = JrJackson::Json.dump(source)
+    expected = {
+      :sym => "a_symbol",
+      :dt => dt.to_s,
+      :co1 => {:one => "uno", :two => "two", :six => 6.0 },
+      :co2 => {:one => "uno", :two => "two", :six => 6.0 },
+      :co3 => {:one => 1.0, :two => 2.0, :six => 6.0 },
+      :co4 => [1, 2, 6],
+      :co5 => today.to_time.to_s
+    }
+    actual = JrJackson::Json.load(json_string, :symbolize_keys => true)
+    assert_equal expected, actual
+  end
+
+  def test_raw_serialize_base_classes
+    # String
+    assert_equal JrJackson::Json.dump("foo"), "\"foo\""
+
+    # Hash and implementations of the Java Hash interface
+    assert_equal JrJackson::Json.dump({"foo" => 1}), "{\"foo\":1}"
+    assert_equal JrJackson::Json.dump(Java::JavaUtil::HashMap.new({"foo" => 1})), "{\"foo\":1}"
+    assert_equal JrJackson::Json.dump(Java::JavaUtil::LinkedHashMap.new({"foo" => 1})), "{\"foo\":1}"
+
+    # Array and implementations of the Java List interface
+    assert_equal JrJackson::Json.dump(["foo", 1]), "[\"foo\",1]"
+    assert_equal JrJackson::Json.dump(Java::JavaUtil::ArrayList.new(["foo", 1])), "[\"foo\",1]"
+    assert_equal JrJackson::Json.dump(Java::JavaUtil::LinkedList.new(["foo", 1])), "[\"foo\",1]"
+    assert_equal JrJackson::Json.dump(Java::JavaUtil::Vector.new(["foo", 1])), "[\"foo\",1]"
+
+    # true/false
+    assert_equal JrJackson::Json.dump(true), "true"
+    assert_equal JrJackson::Json.dump(false), "false"
+
+    # nil
+    assert_equal JrJackson::Json.dump(nil), "null"
+  end
+
+  def test_serialize_date
+    # default date format
+    time_string = "2014-06-10 18:18:40 EDT"
+    source_time = Time.parse(time_string)
+    serialized_output = JrJackson::Json.dump({"time" => source_time})
+    other_time = Time.parse(serialized_output.split('"')[-2])
+    assert_equal other_time.to_f, source_time.to_f
+  end
+
+  def test_serialize_date_date_format
+
+    time = Time.new(2014,6,10,18,18,40, "-04:00")
+    # using date_format option
+    assert_equal "{\"time\":\"2014-06-10\"}", JrJackson::Json.dump({"time" => time}, :date_format => "yyyy-MM-dd")
+    assert_match /\{"time"\:"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}[+-]\d{4}"\}/, JrJackson::Json.dump({"time" => time}, :date_format => "yyyy-MM-dd'T'HH:mm:ss.SSSZ")
+  end
+
+  def test_serialize_date_date_format_timezone
+
+    time = Time.new(2014,6,10,18,18,40, "-04:00")
+    # using date_format and timezone options
+    assert_equal "{\"time\":\"2014-06-10T22:18:40.000+0000\"}", JrJackson::Json.dump({"time" => time}, :date_format => "yyyy-MM-dd'T'HH:mm:ss.SSSZ", :timezone => "UTC")
+    # iso8601 date_format and timezone
+    assert_equal "{\"time\":\"2014-06-10T22:18:40.000Z\"}", JrJackson::Json.dump({"time" => time}, :date_format => "yyyy-MM-dd'T'HH:mm:ss.SSSX", :timezone => "UTC")
+  end
+
+  def test_can_parse_returning_java_objects
+    expected = {"arr"=>[2, 3, 4],
+      "flo"=>0.333E1,
+      "moo"=>"bar",
+      "utf8"=>"żółć",
+      "zzz"=>{"bar"=>-9}}
+    json = '{"utf8":"żółć", "moo": "bar", "zzz": {"bar":-9}, "arr": [2,3,4], "flo": 3.33}'
+
+    actual = JrJackson::Json.parse_java(json)
+
+    assert_equal Java::JavaUtil::HashMap, actual.class
+    assert_equal Java::JavaUtil::ArrayList, actual["arr"].class
+    assert_equal Java::JavaMath::BigDecimal, actual["flo"].class
+    assert_equal "3.33", actual["flo"].to_s
+    assert_equal "bar", actual["moo"]
+    assert_equal "żółć", actual["utf8"]
+    assert_equal Java::JavaUtil::HashMap, actual["zzz"].class
+    assert_equal Bignum, actual["zzz"]["bar"].class
+    assert_equal -9, actual["zzz"]["bar"]
+  end
+
+  def test_can_parse_returning_ruby_objects_string_keys
+    expected = {
+      "a"=>"żółć", # string
+      "b"=>true,    # boolean
+      "c"=>12345,   # number
+      "d"=>
+       [true,
+        [false,
+         [-123456789, nil],
+         0.39676E1,
+         ["Something else.", false],
+         nil]], # mix it up array
+      "e"=>{"zero"=>nil, "one"=>1, "two"=>2, "three"=>[3], "four"=>[0, 1, 2, 3, 4]}, # hash
+      "żółć"=>nil,# nil
+      "h"=>{"a"=>{"b"=>{"c"=>{"d"=>{"e"=>{"f"=>{"g"=>nil}}}}}}},# deep hash, not that deep
+      "i"=>[[[[[[[nil]]]]]]] # deep array, again, not that deep
+    }
+    json = JrJackson::Json.dump(expected)
+    actual = JrJackson::Json.parse_ruby(json)
+    assert_equal expected, actual
+    actual = JrJackson::Ruby.parse(json, {})
+    assert_equal expected, actual
+  end
+
+  def test_can_parse_returning_ruby_objects_symbol_keys
+    expected = {:a=>"Alpha",
+     :b=>true,
+     :c=>12345,
+     :d=>
+      [true, [false, [-123456789, nil], 3.9676, ["Something else.", false], nil]],
+     :e=>{:zero=>nil, :one=>1, :two=>2, :three=>[3], :four=>[0, 1, 2, 3, 4]},
+     :f=>nil,
+     :h=>{:a=>{:b=>{:c=>{:d=>{:e=>{:f=>{:g=>nil}}}}}}},
+     :i=>[[[[[[[nil]]]]]]]
+    }
+    json = JrJackson::Json.dump(expected)
+    actual = JrJackson::Ruby.parse_sym(json, {})
+    assert_equal expected, actual
+  end
+
+  def test_can_parse_nulls
+    expected = {"foo" => nil}
+    json = '{"foo":null}'
+    actual = JrJackson::Json.parse(json)
+    assert_equal expected, actual
+  end
+
+  def test_stringio
+    expected = {"foo" => 5, "utf8" => "żółć"}
+    json = ::StringIO.new('{"foo":5, "utf8":"żółć"}')
+    actual = JrJackson::Json.load_ruby(json)
+    assert_equal expected, actual
+  end
+
+  def test_ruby_io
+    expected = {"foo" => 5, "bar" => 6, "utf8" => "żółć"}
+    json, w = IO.pipe
+    w.write('{"foo":5, "bar":6, "utf8":"żółć"}')
+    w.close
+    actual = JrJackson::Json.load(json)
+    assert_equal expected, actual
+  end
+
+  def test_bad_utf
+    assert_raise JrJackson::ParseError do
+      JrJackson::Json.load("\x82\xAC\xEF")
+    end
+  end
+
+  def test_can_parse_bignum
+    expected = 12345678901234567890123456789
+    json = '{"foo":12345678901234567890123456789}'
+
+    actual = JrJackson::Json.parse(json)['foo']
+    assert_equal expected, actual
+  end
+
+  def test_can_parse_big_decimals
+    expected = BigDecimal.new '0.12345678901234567890123456789'
+    json = '{"foo":0.12345678901234567890123456789}'
+
+    actual = JrJackson::Json.parse(json, :use_bigdecimal => true)['foo']
+    assert_bigdecimal_equal expected, actual
+
+    actual = JrJackson::Json.parse(json, :use_bigdecimal => true, :symbolize_keys => true)[:foo]
+    assert_bigdecimal_equal expected, actual
+
+    actual = JrJackson::Java.parse(json, {})['foo']
+    assert_bigdecimal_similar expected, actual
+
+    actual = JrJackson::Json.parse(json, :use_bigdecimal => true, :raw => true)['foo']
+    assert_bigdecimal_similar expected, actual
+
+  end
+
+  def test_cannot_serialize_object
+    err = assert_raises(JrJackson::ParseError) { JrJackson::Json.dump({"foo" => Object.new}) }
+    assert_match /Cannot serialize instance of: Object/, err.message
+  end
+
+  def test_cannot_serialize_basic_object
+    err = assert_raises(JrJackson::ParseError) { JrJackson::Json.dump({"foo" => BasicObject.new}) }
+    assert_match /Cannot serialize instance of: BasicObject/, err.message
+  end
+
+  def test_cannot_serialize_custom_object
+    err = assert_raises(JrJackson::ParseError) { JrJackson::Json.dump({"foo" => Test::Unit::CustomObj.new}) }
+    assert_match /Cannot serialize instance of: Test::Unit::CustomObj/, err.message
+  end
+
+  def test_supports_pretty_printing
+    object = {"foo" => 5, "utf8" => "żółć"}
+
+    actual = JrJackson::Json.dump(object, :pretty => true)
+    assert_equal "{\n  \"foo\" : 5,\n  \"utf8\" : \"żółć\"\n}", actual
+  end
+
+  def test_can_serialise_non_string_keys
+    object = {5 => "foo"}
+    actual = JrJackson::Json.dump(object)
+    assert_equal "{\"5\":\"foo\"}", actual
+  end
+
+  def test_can_serialise_regex_match_data
+    re = %r|(foo)(bar)(baz)|
+    m = re.match('foobarbaz')
+    object = {'matched' => m[2]}
+    actual = JrJackson::Json.dump(object)
+    assert_equal "{\"matched\":\"bar\"}", actual
+  end
+
+  def test_can_mix_java_and_ruby_objects
+    json = '{"utf8":"żółć", "moo": "bar", "arr": [2,3,4], "flo": 3.33}'
+    timeobj = Time.new(2015,11,11,11,11,11).utc
+    expected = '{"mixed":{"arr":[2,3,4],"utf8":"żółć","flo":3.33,"zzz":{"one":1.0,"two":2,"six":6.0},"moo":"bar"},"time":"2015-11-11 11:11:11 +0000"}'
+    object = JrJackson::Json.parse_java(json)
+    object["zzz"] = CustomToJson.new(1.0, 2, 6.0)
+    mixed = {"mixed" => object}
+    mixed['time'] = timeobj
+    actual = JrJackson::Json.dump(mixed)
+    assert_equal expected, actual
+  end
+
+  # -----------------------------
+
+  def assert_bigdecimal_equal(expected, actual)
+    assert_equal expected, actual
+    assert_equal expected.class, actual.class
+    assert_equal BigDecimal, actual.class
+  end
+
+  def assert_bigdecimal_similar(expected, actual)
+    assert_equal BigDecimal.new(expected.to_s).round(11), BigDecimal.new(actual.to_s).round(11)
+    assert_equal Java::JavaMath::BigDecimal, actual.class
+  end
+end