oj 0.9.0 → 1.0.0

data/ext/oj/load.c

@@ -533,7 +533,7 @@ read_array(ParseInfo pi, int hint) {
 		RSTRUCT_PTR(a)[cnt] = e;
 #endif
 	    } else {
-		a = rb_ary_push(a, e);
+		rb_ary_push(a, e);
 	    }
 	    cnt++;
 	}

data/ext/oj/oj.c

@@ -1,5 +1,6 @@
 /* oj.c
- * Copyright (c) 2011, Peter Ohler
+ * Copyright (c) 2012, Peter Ohler
+ *
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -60,6 +61,8 @@ VALUE	oj_bag_class;
 VALUE	oj_struct_class;
 VALUE	oj_time_class;
 
+VALUE	oj_slash_string;
+
 static VALUE	auto_define_sym;
 static VALUE	circular_sym;
 static VALUE	compat_sym;
@@ -73,7 +76,7 @@ static VALUE	strict_sym;
 Cache   oj_class_cache = 0;
 Cache   oj_attr_cache = 0;
 
-static struct _Options  default_options = {
+struct _Options	oj_default_options = {
     { '\0' },		// encoding
     0,			// indent
     No,			// circular
@@ -94,13 +97,13 @@ static struct _Options  default_options = {
 static VALUE
 get_def_opts(VALUE self) {
     VALUE       opts = rb_hash_new();
-    int         elen = (int)strlen(default_options.encoding);
+    int         elen = (int)strlen(oj_default_options.encoding);
 
-    rb_hash_aset(opts, encoding_sym, (0 == elen) ? Qnil : rb_str_new(default_options.encoding, elen));
-    rb_hash_aset(opts, indent_sym, INT2FIX(default_options.indent));
-    rb_hash_aset(opts, circular_sym, (Yes == default_options.circular) ? Qtrue : ((No == default_options.circular) ? Qfalse : Qnil));
-    rb_hash_aset(opts, auto_define_sym, (Yes == default_options.auto_define) ? Qtrue : ((No == default_options.auto_define) ? Qfalse : Qnil));
-    switch (default_options.mode) {
+    rb_hash_aset(opts, encoding_sym, (0 == elen) ? Qnil : rb_str_new(oj_default_options.encoding, elen));
+    rb_hash_aset(opts, indent_sym, INT2FIX(oj_default_options.indent));
+    rb_hash_aset(opts, circular_sym, (Yes == oj_default_options.circular) ? Qtrue : ((No == oj_default_options.circular) ? Qfalse : Qnil));
+    rb_hash_aset(opts, auto_define_sym, (Yes == oj_default_options.auto_define) ? Qtrue : ((No == oj_default_options.auto_define) ? Qfalse : Qnil));
+    switch (oj_default_options.mode) {
     case StrictMode:	rb_hash_aset(opts, mode_sym, strict_sym);	break;
     case CompatMode:	rb_hash_aset(opts, mode_sym, compat_sym);	break;
     case NullMode:	rb_hash_aset(opts, mode_sym, null_sym);		break;
@@ -130,8 +133,8 @@ get_def_opts(VALUE self) {
 static VALUE
 set_def_opts(VALUE self, VALUE opts) {
     struct _YesNoOpt    ynos[] = {
-        { circular_sym, &default_options.circular },
-        { auto_define_sym, &default_options.auto_define },
+        { circular_sym, &oj_default_options.circular },
+        { auto_define_sym, &oj_default_options.auto_define },
         { Qnil, 0 }
     };
     YesNoOpt    o;
@@ -143,29 +146,29 @@ set_def_opts(VALUE self, VALUE opts) {
     if (Qundef == v) {
 	// no change
     } else if (Qnil == v) {
-        *default_options.encoding = '\0';
+        *oj_default_options.encoding = '\0';
     } else {
         Check_Type(v, T_STRING);
-        strncpy(default_options.encoding, StringValuePtr(v), sizeof(default_options.encoding) - 1);
+        strncpy(oj_default_options.encoding, StringValuePtr(v), sizeof(oj_default_options.encoding) - 1);
     }
 
     v = rb_hash_aref(opts, indent_sym);
     if (Qnil != v) {
         Check_Type(v, T_FIXNUM);
-        default_options.indent = FIX2INT(v);
+        oj_default_options.indent = FIX2INT(v);
     }
 
     v = rb_hash_lookup2(opts, mode_sym, Qundef);
     if (Qundef == v || Qnil == v) {
 	// ignore
     } else if (object_sym == v) {
-        default_options.mode = ObjectMode;
+        oj_default_options.mode = ObjectMode;
     } else if (strict_sym == v) {
-        default_options.mode = StrictMode;
+        oj_default_options.mode = StrictMode;
     } else if (compat_sym == v) {
-        default_options.mode = CompatMode;
+        oj_default_options.mode = CompatMode;
     } else if (null_sym == v) {
-        default_options.mode = NullMode;
+        oj_default_options.mode = NullMode;
     } else {
         rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.\n");
     }
@@ -243,7 +246,7 @@ parse_options(VALUE ropts, Options copts) {
 static VALUE
 load(char *json, int argc, VALUE *argv, VALUE self) {
     VALUE		obj;
-    struct _Options	options = default_options;
+    struct _Options	options = oj_default_options;
 
     if (1 == argc) {
 	parse_options(*argv, &options);
@@ -311,7 +314,7 @@ load_file(int argc, VALUE *argv, VALUE self) {
 static VALUE
 dump(int argc, VALUE *argv, VALUE self) {
     char                *json;
-    struct _Options     copts = default_options;
+    struct _Options     copts = oj_default_options;
     VALUE               rstr;
     
     if (2 == argc) {
@@ -343,7 +346,7 @@ dump(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE
 to_file(int argc, VALUE *argv, VALUE self) {
-    struct _Options     copts = default_options;
+    struct _Options     copts = oj_default_options;
     
     if (3 == argc) {
         parse_options(argv[2], &copts);
@@ -393,10 +396,14 @@ void Init_oj() {
     object_sym = ID2SYM(rb_intern("object"));		rb_ary_push(keep, object_sym);
     strict_sym = ID2SYM(rb_intern("strict"));		rb_ary_push(keep, strict_sym);
 
-    default_options.mode = ObjectMode;
+    oj_slash_string = rb_str_new2("/");			rb_ary_push(keep, oj_slash_string);
+
+    oj_default_options.mode = ObjectMode;
 
     oj_cache_new(&oj_class_cache);
     oj_cache_new(&oj_attr_cache);
+
+    oj_init_doc();
 }
 
 void

data/ext/oj/oj.h

@@ -91,12 +91,18 @@ extern void	oj_write_obj_to_file(VALUE obj, const char *path, Options copts);
 
 extern void	_oj_raise_error(const char *msg, const char *xml, const char *current, const char* file, int line);
 
+extern void	oj_init_doc(void);
+
 extern VALUE    Oj;
+extern struct _Options	oj_default_options;
 
 extern VALUE	oj_bag_class;
+extern VALUE	oj_doc_class;
 extern VALUE	oj_struct_class;
 extern VALUE	oj_time_class;
 
+extern VALUE	oj_slash_string;
+
 extern ID	oj_as_json_id;
 extern ID	oj_at_id;
 extern ID	oj_instance_variables_id;

data/lib/oj.rb

@@ -1,4 +1,5 @@
-# Copyright (c) 2011, Peter Ohler<br>
+# Copyright (c) 2011, Peter Ohler
+#
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module. 
-  VERSION = '0.9.0'
+  VERSION = '1.0.0'
 end

data/test/perf_fast.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby -wW1
+# encoding: UTF-8
+
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'optparse'
+require 'yajl'
+require 'perf'
+require 'json'
+require 'json/ext'
+require 'oj'
+
+$verbose = false
+$indent = 0
+$iter = 100000
+$gets = 0
+$fetch = false
+
+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("-g", "--gets [Int]", Integer, "number of gets")  { |i| $gets = i }
+opts.on("-f", "fetch")                                    { $fetch = true }
+opts.on("-h", "--help", "Show this display")              { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+# This just navigates to each leaf of the JSON structure.
+def dig(obj, &blk)
+  case obj
+  when Array
+    obj.each { |e| dig(e, &blk) }
+  when Hash
+    obj.values.each { |e| dig(e, &blk) }
+  else
+    blk.yield(obj)
+  end
+end
+
+$obj = {
+  'a' => 'Alpha', # string
+  'b' => true,    # boolean
+  'c' => 12345,   # number
+  'd' => [ true, [false, {'12345' => 12345, 'nil' => nil}, 3.967, { 'x' => 'something', 'y' => false, 'z' => true}, nil]], # mix it up array
+  'e' => { 'one' => 1, 'two' => 2 }, # hash
+  'f' => nil,     # nil
+  'g' => 12345678901234567890123456789, # big number
+  'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
+  'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
+}
+
+Oj.default_options = { :indent => $indent, :mode => :compat }
+
+$json = Oj.dump($obj)
+$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::Doc', $obj, 'load', 'dump') { |o| Oj::Doc.open(Oj.dump(o, :mode => :strict)) { |f| f.fetch() } }
+capture_error('Yajl', $obj, 'encode', 'parse') { |o| Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
+capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o| JSON.generator = JSON::Ext::Generator; JSON::Ext::Parser.new(JSON.generate(o)).parse }
+
+if $verbose
+  puts "json:\n#{$json}\n"
+end
+
+puts '-' * 80
+puts "Parse Performance"
+perf = Perf.new()
+perf.add('Oj::Doc', 'parse') { Oj::Doc.open($json) {|f| } } unless $failed.has_key?('Oj::Doc')
+perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
+perf.add('JSON::Ext', 'parse') { JSON::Ext::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
+perf.run($iter)
+
+if 0 < $gets
+  puts '-' * 80
+  puts "Parse and get all values Performance"
+  perf = Perf.new()
+  perf.add('Oj::Doc', 'parse') { Oj::Doc.open($json) {|f| $gets.times { f.each_value() {} } } } unless $failed.has_key?('Oj::Doc')
+  perf.add('Yajl', 'parse') { $gets.times { dig(Yajl::Parser.parse($json)) {} } } unless $failed.has_key?('Yajl')
+  perf.add('JSON::Ext', 'parse') { $gets.times { dig(JSON::Ext::Parser.new($json).parse) {} } } unless $failed.has_key?('JSON::Ext')
+  perf.run($iter)
+end
+
+if $fetch
+  puts '-' * 80
+  puts "fetch nested Performance"
+  json_hash = Oj.load($json, :mode => :strict)
+  Oj::Doc.open($json) do |fast|
+    #puts "*** C fetch: #{fast.fetch('/d/2/4/y')}"
+    #puts "*** Ruby fetch: #{json_hash.fetch('d', []).fetch(1, []).fetch(3, []).fetch('x', nil)}"
+    perf = Perf.new()
+    perf.add('Oj::Doc', 'fetch') { fast.fetch('/d/2/4/x'); fast.fetch('/h/a/b/c/d/e/f/g'); fast.fetch('/i/1/1/1/1/1/1/1') }
+    # version that fails gracefully
+    perf.add('Ruby', 'fetch') do
+      json_hash.fetch('d', []).fetch(1, []).fetch(3, []).fetch('x', nil)
+      json_hash.fetch('h', {}).fetch('a', {}).fetch('b', {}).fetch('c', {}).fetch('d', {}).fetch('e', {}).fetch('f', {}).fetch('g', {})
+      json_hash.fetch('i', []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, nil)
+    end
+    # version that raises if the path is incorrect
+#    perf.add('Ruby', 'fetch') { $fetch.times { json_hash['d'][1][3][1] } }
+    perf.run($iter)
+  end
+end
+
+unless $failed.empty?
+  puts "The following packages were not included for the reason listed"
+  $failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
+end

data/test/perf_strict.rb

@@ -82,14 +82,17 @@ files = opts.parse(ARGV)
 
 if $with_nums
   $obj = {
-    'a' => 'Alpha',
-    'b' => true,
-    'c' => 12345,
-    'd' => [ true, [false, [12345, nil], 3.967, ['something', false], nil]],
-    'e' => { 'one' => 1, 'two' => 2 },
-    'f' => nil,
+    'a' => 'Alpha', # string
+    'b' => true,    # boolean
+    'c' => 12345,   # number
+    'd' => [ true, [false, [12345, nil], 3.967, ['something', false], nil]], # mix it up array
+    'e' => { 'one' => 1, 'two' => 2 }, # hash
+    'f' => nil,     # nil
+    #'g' => 12345678901234567890123456789, # big number
+    'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
+    'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
   }
-  $obj['h'] = 12345678901234567890123456789 if $with_bignum
+  $obj['g'] = 12345678901234567890123456789 if $with_bignum
 else
   $obj = {
     'a' => 'Alpha',
@@ -98,9 +101,11 @@ else
     'd' => [ true, [false, ['12345', nil], '3.967', ['something', false], nil]],
     'e' => { '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
-$obj['g'] = Jazz.new() if $with_object
+$obj['j'] = Jazz.new() if $with_object
 
 Oj.default_options = { :indent => $indent, :mode => :compat }
 Ox.default_options = { :indent => $indent, :mode => :object }

data/test/test_fast.rb

@@ -0,0 +1,331 @@
+#!/usr/bin/env ruby -wW1
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'test/unit'
+require 'oj'
+
+$json1 = %{{
+  "array": [
+    {
+      "num"   : 3,
+      "string": "message",
+      "hash"  : {
+        "h2"  : {
+          "a" : [ 1, 2, 3 ]
+        }
+      }
+    }
+  ],
+  "boolean" : true
+}}
+
+class DocTest < ::Test::Unit::TestCase
+  def test_nil
+    json = %{null}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(NilClass, doc.type)
+      assert_equal(nil, doc.fetch())
+    end
+  end
+
+  def test_true
+    json = %{true}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(TrueClass, doc.type)
+      assert_equal(true, doc.fetch())
+    end
+  end
+
+  def test_false
+    json = %{false}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(FalseClass, doc.type)
+      assert_equal(false, doc.fetch())
+    end
+  end
+
+  def test_string
+    json = %{"a string"}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(String, doc.type)
+      assert_equal('a string', doc.fetch())
+    end
+  end
+
+  def test_fixnum
+    json = %{12345}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Fixnum, doc.type)
+      assert_equal(12345, doc.fetch())
+    end
+  end
+
+  def test_float
+    json = %{12345.6789}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Float, doc.type)
+      assert_equal(12345.6789, doc.fetch())
+    end
+  end
+
+  def test_float_exp
+    json = %{12345.6789e7}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Float, doc.type)
+      assert_equal(12345.6789e7, doc.fetch())
+    end
+  end
+
+  def test_array_empty
+    json = %{[]}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Array, doc.type)
+      assert_equal([], doc.fetch())
+    end
+  end
+
+  def test_array
+    json = %{[true,false]}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Array, doc.type)
+      assert_equal([true, false], doc.fetch())
+    end
+  end
+
+  def test_hash_empty
+    json = %{{}}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Hash, doc.type)
+      assert_equal({}, doc.fetch())
+    end
+  end
+
+  def test_hash
+    json = %{{"one":true,"two":false}}
+    Oj::Doc.open(json) do |doc|
+      assert_equal(Hash, doc.type)
+      assert_equal({'one' => true, 'two' => false}, doc.fetch())
+    end
+  end
+
+  # move() and where?()
+  def test_move_hash
+    json = %{{"one":{"two":false}}}
+    Oj::Doc.open(json) do |doc|
+      doc.move('/one')
+      assert_equal('/one', doc.where?)
+      doc.move('/one/two')
+      assert_equal('/one/two', doc.where?)
+    end
+  end
+
+  def test_move_array
+    json = %{[1,[2,true]]}
+    Oj::Doc.open(json) do |doc|
+      doc.move('/1')
+      assert_equal('/1', doc.where?)
+      doc.move('/2/1')
+      assert_equal('/2/1', doc.where?)
+    end
+  end
+
+  def test_move
+    Oj::Doc.open($json1) do |doc|
+      [ '/',
+        '/array',
+        '/boolean',
+        '/array/1/hash/h2/a/3',
+      ].each do |p|
+        doc.move(p)
+        assert_equal(p, doc.where?)
+      end
+      begin
+        doc.move('/array/x')
+      rescue Exception => e
+        assert_equal('/', doc.where?)
+        assert(true)
+      end
+    end
+  end
+
+  def test_move_relative
+    Oj::Doc.open($json1) do |doc|
+      [['/', 'array', '/array'],
+       ['/array', '1/num', '/array/1/num'],
+       ['/array/1/hash', 'h2/a', '/array/1/hash/h2/a'],
+       ['/array/1', 'hash/h2/a/2', '/array/1/hash/h2/a/2'],
+       ['/array/1/hash', '../string', '/array/1/string'],
+       ['/array/1/hash', '..', '/array/1'],
+      ].each do |start,path,where|
+        doc.move(start)
+        doc.move(path)
+        assert_equal(where, doc.where?)
+      end
+    end
+  end
+
+  def test_type
+    Oj::Doc.open($json1) do |doc|
+      [['/', Hash],
+       ['/array', Array],
+       ['/array/1', Hash],
+       ['/array/1/num', Fixnum],
+       ['/array/1/string', String],
+       ['/array/1/hash/h2/a', Array],
+       ['/array/1/hash/../num', Fixnum],
+       ['/array/1/hash/../..', Array],
+      ].each do |path,type|
+        assert_equal(type, doc.type(path))
+      end
+    end
+  end
+
+  def test_local_key
+    Oj::Doc.open($json1) do |doc|
+      [['/', nil],
+       ['/array', 'array'],
+       ['/array/1', 1],
+       ['/array/1/num', 'num'],
+       ['/array/1/string', 'string'],
+       ['/array/1/hash/h2/a', 'a'],
+       ['/array/1/hash/../num', 'num'],
+       ['/array/1/hash/..', 1],
+       ['/array/1/hash/../..', 'array'],
+      ].each do |path,key|
+        doc.move(path)
+        assert_equal(key, doc.local_key())
+      end
+    end
+  end
+
+  def test_fetch_move
+    Oj::Doc.open($json1) do |doc|
+      [['/array/1/num', 3],
+       ['/array/1/string', 'message'],
+       ['/array/1/hash/h2/a', [1, 2, 3]],
+       ['/array/1/hash/../num', 3],
+       ['/array/1/hash/..', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
+       ['/array/1/hash/../..', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
+       ['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
+       ['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
+       ['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
+      ].each do |path,val|
+        doc.move(path)
+        assert_equal(val, doc.fetch())
+      end
+    end
+  end
+
+  def test_fetch_path
+    Oj::Doc.open($json1) do |doc|
+      [['/array/1/num', 3],
+       ['/array/1/string', 'message'],
+       ['/array/1/hash/h2/a', [1, 2, 3]],
+       ['/array/1/hash/../num', 3],
+       ['/array/1/hash/..', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
+       ['/array/1/hash/../..', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
+       ['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
+       ['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
+       ['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
+      ].each do |path,val|
+        assert_equal(val, doc.fetch(path))
+      end
+    end
+  end
+
+  def test_home
+    Oj::Doc.open($json1) do |doc|
+      doc.move('/array/1/num')
+      doc.home()
+      assert_equal('/', doc.where?)
+    end
+  end
+
+  def test_each_value_root
+    Oj::Doc.open($json1) do |doc|
+      values = []
+      doc.each_value() { |v| values << v.to_s }
+      assert_equal(['1', '2', '3', '3', 'message', 'true'], values.sort)
+    end
+  end
+
+  def test_each_value_move
+    Oj::Doc.open($json1) do |doc|
+      doc.move('/array/1/hash')
+      values = []
+      doc.each_value() { |v| values << v.to_s }
+      assert_equal(['1', '2', '3'], values.sort)
+    end
+  end
+
+  def test_each_value_path
+    Oj::Doc.open($json1) do |doc|
+      values = []
+      doc.each_value('/array/1/hash') { |v| values << v.to_s }
+      assert_equal(['1', '2', '3'], values.sort)
+    end
+  end
+
+  def test_each_child_move
+    Oj::Doc.open($json1) do |doc|
+      locations = []
+      doc.move('/array/1/hash/h2/a')
+      doc.each_child() { |d| locations << d.where? }
+      assert_equal(['/array/1/hash/h2/a/1', '/array/1/hash/h2/a/2', '/array/1/hash/h2/a/3'], locations)
+      locations = []
+      doc.move('/array/1')
+      doc.each_child() { |d| locations << d.where? }
+      assert_equal(['/array/1/num', '/array/1/string', '/array/1/hash'], locations)
+    end
+  end
+
+  def test_each_child_path
+    Oj::Doc.open($json1) do |doc|
+      locations = []
+      doc.each_child('/array/1/hash/h2/a') { |d| locations << d.where? }
+      assert_equal(['/array/1/hash/h2/a/1', '/array/1/hash/h2/a/2', '/array/1/hash/h2/a/3'], locations)
+      locations = []
+      doc.each_child('/array/1') { |d| locations << d.where? }
+      assert_equal(['/array/1/num', '/array/1/string', '/array/1/hash'], locations)
+    end
+  end
+
+  def test_size
+    Oj::Doc.open('[1,2,3]') do |doc|
+      assert_equal(4, doc.size)
+    end
+    Oj::Doc.open('{"a":[1,2,3]}') do |doc|
+      assert_equal(5, doc.size)
+    end
+  end
+
+  def test_open_file
+    filename = 'open_file_test.json'
+    File.open(filename, 'w') { |f| f.write('{"a":[1,2,3]}') }
+    Oj::Doc.open_file(filename) do |doc|
+      assert_equal(5, doc.size)
+    end
+  end
+
+  def test_dump
+    Oj::Doc.open('[1,[2,3]]') do |doc|
+      assert_equal('[1,[2,3]]', doc.dump())
+    end
+    Oj::Doc.open('[1,[2,3]]') do |doc|
+      assert_equal('[2,3]', doc.dump('/2'))
+    end
+  end
+
+  def test_each_leaf
+    results = Oj::Doc.open('[1,[2,3]]') do |doc|
+      h = {}
+      doc.each_leaf() { |d| h[d.where?] = d.fetch() }
+      h
+    end
+    assert_equal({'/1' => 1, '/2/1' => 2, '/2/2' => 3}, results)
+  end
+
+end # DocTest