mongo 1.0.9 → 1.1

data/test/bson/byte_buffer_test.rb

@@ -0,0 +1,190 @@
+# encoding: binary
+require './test/test_helper'
+
+class ByteBufferTest < Test::Unit::TestCase
+  include BSON
+
+  def setup
+    @buf = ByteBuffer.new
+  end
+  
+  def test_initial_state
+    assert_equal 0, @buf.position
+    assert_equal [], @buf.to_a
+    assert_equal "", @buf.to_s
+    assert_equal 0, @buf.length
+  end
+
+  def test_nil_get_returns_one_byte
+    @buf.put_array([1, 2, 3, 4])
+    @buf.rewind
+    assert_equal 1, @buf.get
+  end
+
+  def test_one_get_returns_array_length_one
+    @buf.put_array([1, 2, 3, 4])
+    @buf.rewind
+    assert_equal [1], @buf.get(1)
+  end
+
+  def test_zero_get_returns_empty_array
+    @buf.put_array([1, 2, 3, 4])
+    @buf.rewind
+    assert_equal [], @buf.get(0)
+  end
+
+  def test_length
+    @buf.put_int 3
+    assert_equal 4, @buf.length
+  end
+
+  def test_default_order
+    assert_equal :little_endian, @buf.order
+  end
+
+  def test_long_length
+    @buf.put_long 1027
+    assert_equal 8, @buf.length
+  end
+
+  def test_get_long
+    @buf.put_long 1027
+    @buf.rewind
+    assert_equal 1027, @buf.get_long
+  end
+
+  def test_get_double
+    @buf.put_double 41.2
+    @buf.rewind
+    assert_equal 41.2, @buf.get_double
+  end
+  
+  if defined?(Encoding)
+    def test_serialize_cstr_converts_encoding_to_utf8
+      theta = "hello \xC8".force_encoding("ISO-8859-7")
+      ByteBuffer.serialize_cstr(@buf, theta)
+      assert_equal "hello \xCE\x98\0", @buf.to_s
+      assert_equal Encoding.find('binary'), @buf.to_s.encoding
+    end
+    
+    def test_serialize_cstr_validates_data_as_utf8
+      assert_raises(Encoding::UndefinedConversionError) do
+        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+      end
+    end
+  else
+    def test_serialize_cstr_forces_encoding_to_utf8
+      # Unicode snowman (\u2603)
+      ByteBuffer.serialize_cstr(@buf, "hello \342\230\203")
+      assert_equal "hello \342\230\203\0", @buf.to_s
+    end
+    
+    def test_serialize_cstr_validates_data_as_utf8
+      assert_raises(BSON::InvalidStringEncoding) do
+        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+      end
+    end
+  end
+  
+  def test_put_negative_byte
+    @buf.put(-1)
+    @buf.rewind
+    assert_equal 255, @buf.get
+    assert_equal "\xFF", @buf.to_s
+  end
+  
+  def test_put_with_offset
+    @buf.put(1)
+    @buf.put(2, 0)
+    @buf.put(3, 3)
+    assert_equal "\x02\x00\x00\x03", @buf.to_s
+  end
+  
+  def test_put_array_with_offset
+    @buf.put(1)
+    @buf.put_array([2, 3], 0)
+    @buf.put_array([4, 5], 4)
+    assert_equal "\x02\x03\x00\x00\x04\x05", @buf.to_s
+  end
+  
+  def test_put_int_with_offset
+    @buf.put(1)
+    @buf.put_int(2, 0)
+    @buf.put_int(3, 5)
+    assert_equal "\x02\x00\x00\x00\x00\x03\x00\x00\x00", @buf.to_s
+  end
+  
+  def test_put_long_with_offset
+    @buf.put(1)
+    @buf.put_long(2, 0)
+    @buf.put_long(3, 9)
+    assert_equal(
+      "\x02\x00\x00\x00\x00\x00\x00\x00" +
+      "\x00" +
+      "\x03\x00\x00\x00\x00\x00\x00\x00",
+      @buf.to_s)
+  end
+  
+  def test_put_binary
+    @buf.put(1)
+    @buf.put_binary("\x02\x03", 0)
+    @buf.put_binary("\x04\x05", 4)
+    assert_equal "\x02\x03\x00\x00\x04\x05", @buf.to_s
+  end
+  
+  def test_rewrite
+    @buf.put_int(0)
+    @buf.rewind
+    @buf.put_int(1027)
+    assert_equal 4, @buf.length
+    @buf.rewind
+    assert_equal 1027, @buf.get_int
+    assert_equal 4, @buf.position
+  end
+
+  def test_prepend_byte_buffer
+    @buf.put_int(4)
+    new_buf = ByteBuffer.new([5, 0, 0, 0])
+    @buf.prepend!(new_buf)
+    assert_equal [5, 0, 0, 0, 4, 0, 0, 0], @buf.to_a
+  end
+
+  def test_append_byte_buffer
+    @buf.put_int(4)
+    new_buf = ByteBuffer.new([5, 0, 0, 0])
+    @buf.append!(new_buf)
+    assert_equal [4, 0, 0, 0, 5, 0, 0, 0], @buf.to_a
+  end
+  
+  def test_array_as_initial_input
+    @buf = ByteBuffer.new([5, 0, 0, 0])
+    assert_equal 4, @buf.size
+    assert_equal "\x05\x00\x00\x00", @buf.to_s
+    assert_equal [5, 0, 0, 0], @buf.to_a
+    @buf.put_int(32)
+    @buf.rewind
+    assert_equal 5, @buf.get_int
+    assert_equal 32, @buf.get_int
+  end
+  
+  def test_binary_string_as_initial_input
+    str = "abcd"
+    str.force_encoding('binary') if str.respond_to?(:force_encoding)
+    @buf = ByteBuffer.new(str)
+    assert_equal "abcd", @buf.to_s
+    assert_equal [97, 98, 99, 100], @buf.to_a
+    @buf.put_int(0)
+    assert_equal [97, 98, 99, 100, 0, 0, 0, 0], @buf.to_a
+  end
+  
+  def test_more
+    assert !@buf.more?
+    @buf.put_int(5)
+    assert !@buf.more?
+    @buf.rewind
+    assert @buf.more?
+    @buf.get_int
+    assert !@buf.more?
+  end
+
+end

data/test/bson/c_encode_test.rb

@@ -0,0 +1,51 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+require 'benchmark'
+
+MEDIUM = {
+  'integer' => 5,
+  'number' => 5.05,
+  'boolean' => false,
+  'array' => ['test', 'benchmark']
+}
+
+
+LARGE = {
+  'base_url' => 'http://www.example.com/test-me',
+  'total_word_count' => 6743,
+  'access_time' => 123, #Time.now,
+  'meta_tags' => {
+    'description' => 'i am a long description string',
+    'author' => 'Holly Man',
+    'dynamically_created_meta_tag' => 'who know\n what'
+  },
+  'page_structure' => {
+    'counted_tags' => 3450,
+    'no_of_js_attached' => 10,
+    'no_of_images' => 6
+  },
+  'harvested_words' => ['10gen','web','open','source','application','paas',
+                        'platform-as-a-service','technology','helps',
+                        'developers','focus','building','mongodb','mongo'] * 20
+}
+
+class CBSONTest < Test::Unit::TestCase
+  include BSON
+
+  def setup
+    @encoder = BSON::BSON_CODER
+  end
+
+  def test_nested_string
+    t0 = Time.now
+    50000.times do
+      @encoder.serialize({'doc' => MEDIUM})
+    end
+    t1 = Time.now
+    puts t1 - t0
+  end
+
+end

data/test/bson/java_bson_test.rb

@@ -0,0 +1,146 @@
+# encoding:utf-8
+require './test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+require 'benchmark'
+
+MEDIUM = {
+  'integer' => 5,
+  'number' => 5.05,
+  'boolean' => false,
+  'array' => ['test', 'benchmark']
+}
+
+
+LARGE = {
+  'base_url' => 'http://www.example.com/test-me',
+  'total_word_count' => 6743,
+  'access_time' => 1,# Time.now,
+  'meta_tags' => {
+    'description' => 'i am a long description string',
+    'author' => 'Holly Man',
+    'dynamically_created_meta_tag' => 'who know\n what'
+  },
+  'page_structure' => {
+    'counted_tags' => 3450,
+    'no_of_js_attached' => 10,
+    'no_of_images' => 6
+  },
+  'harvested_words' => ['10gen','web','open','source','application','paas',
+                        'platform-as-a-service','technology','helps',
+                        'developers','focus','building','mongodb','mongo'] * 20
+}
+
+# Tests and benchmarks specific to the JRuby BSON serializer
+if RUBY_PLATFORM =~ /java/
+class BSONTest < Test::Unit::TestCase
+  include BSON
+
+  def setup
+    @encoder = BSON::BSON_RUBY
+    @decoder = BSON::BSON_RUBY
+    @con = Mongo::Connection.new
+  end
+
+  def assert_doc_pass(doc, options={})
+    bson = @encoder.serialize(doc)
+    if options[:debug]
+      puts "DEBUGGIN DOC:"
+      p bson.to_a
+      puts "DESERIALIZES TO:"
+      p @decoder.deserialize(bson)
+    end
+    assert_equal @decoder.serialize(doc).to_a, bson.to_a
+    assert_equal doc, @decoder.deserialize(bson)
+  end
+
+#  def test_bench_big_string
+#    t0 = Time.now
+#    @con['foo']['bar'].remove
+#    doc = {'doc' => 'f' * 2_000_000}
+#    10.times do
+#      @con['foo']['bar'].save({'d' => doc})
+#      @con['foo']['bar'].find.to_a
+#    end
+#    puts "Big String"
+#    puts Time.now - t0
+#  end
+#
+#  def test_big_array
+#    t0 = Time.now
+#    @con['foo']['bar'].remove
+#    doc = {'doc' => 'f' * 2_000_000}
+#    10.times do
+#      @con['foo']['bar'].save({'d' => doc})
+#      @con['foo']['bar'].find.to_a
+#    end
+#    puts "Big String"
+#    puts Time.now - t0
+#  end
+#
+#  def test_string
+#    doc = {'doc' => "Hello world!", 'awesome' => true, 'a' => 1, 'b' => 4_333_433_232, 'c' => 2.33, 'd' => nil,
+#    'f' => BSON::Code.new("function"), 'g' => BSON::ObjectId.new, 'h' => [1, 2, 3]}
+#    bson = @encoder.serialize(doc)
+#    d = @encoder.deserialize(bson)
+#    puts "Array"
+#    puts d
+#    puts d['h']
+#    puts "End Array"
+#    puts d['h'][0]
+#    puts d['h'][1]
+#    puts (d['h'][2] + 100).class
+#    puts "ObjecId Info"
+#    bson2 = @encoder.serialize(d)
+#    doc2 = @encoder.deserialize(bson2)
+#    assert_equal doc2, @encoder.deserialize(bson)
+#  end
+#
+
+  def test_eval
+    code = BSON::Code.new('f')
+    oh = BSON::OrderedHash.new
+    oh[:$eval] = code
+    oh[:args]  = [1]
+
+    assert_equal BSON::BSON_RUBY.serialize(oh).to_a, BSON::BSON_JAVA.serialize(oh).to_a
+  end
+
+#  def test_oid
+#    b = Java::OrgBsonTypes::ObjectId.new.toByteArray
+#    o = ObjectId.new(b)
+#    p o
+#  end
+#
+#  def test_speed
+#    @con['foo']['bar'].remove
+#
+#    puts "Test OID"
+#    t0 = Time.now
+#    5000.times do
+#      BSON::ObjectId.new
+#    end
+#    puts Time.now - t0
+#
+#    puts "Test insert"
+#    t0 = Time.now
+#    1000.times do |n|
+#      if n % 1000 == 0
+#        puts Time.now - t0
+#        t0 = Time.now
+#      end
+#      @con['foo']['bar'].insert({'doc' => MEDIUM})
+#    end
+#    puts Time.now - t0
+#
+#    puts "Test query / deserialize"
+#    t0 = Time.now
+#    @con['foo']['bar'].find.to_a
+#    t1 = Time.now
+#    puts t1 - t0
+#  end
+
+
+end
+end

data/test/bson/jruby_bson_test.rb

@@ -0,0 +1,24 @@
+# encoding:utf-8
+require './test/test_helper'
+
+# Special tests for the JRuby encoder only
+if RUBY_PLATFORM =~ /java/
+
+class JRubyBSONTest < Test::Unit::TestCase
+  include BSON
+
+  def setup
+    @encoder = BSON::BSON_CODER
+    @decoder = BSON::BSON_RUBY
+  end
+
+  def test_object_id
+    oid = {'doc' => BSON::ObjectId.new}
+    p oid['doc'].data
+    bson = @encoder.serialize(oid)
+    assert_equal oid, @encoder.deserialize(bson)
+  end
+
+end
+
+end

data/test/bson/jruby_encode_test.rb

@@ -0,0 +1,438 @@
+# encoding:utf-8
+require 'test/test_helper'
+require 'complex'
+require 'bigdecimal'
+require 'rational'
+require 'benchmark'
+
+MEDIUM = {
+  'integer' => 5,
+  'number' => 5.05,
+  'boolean' => false,
+  'array' => ['test', 'benchmark']
+}
+
+
+LARGE = {
+  'base_url' => 'http://www.example.com/test-me',
+  'total_word_count' => 6743,
+  'access_time' => 123, #Time.now,
+  'meta_tags' => {
+    'description' => 'i am a long description string',
+    'author' => 'Holly Man',
+    'dynamically_created_meta_tag' => 'who know\n what'
+  },
+  'page_structure' => {
+    'counted_tags' => 3450,
+    'no_of_js_attached' => 10,
+    'no_of_images' => 6
+  },
+  'harvested_words' => ['10gen','web','open','source','application','paas',
+                        'platform-as-a-service','technology','helps',
+                        'developers','focus','building','mongodb','mongo'] * 20
+}
+
+class BSONTest < Test::Unit::TestCase
+  include BSON
+
+  def setup
+    @encoder = BSON::BSON_CODER
+  end
+
+  def assert_doc_pass(doc)
+    bson = @encoder.serialize(doc)
+    p bson.to_a
+    puts "#{doc.inspect} serializes to #{bson.inspect}"
+
+    assert_equal doc, BSON::BSON_RUBY.deserialize(bson)
+  end
+
+  def test_string
+    doc = {'doc' => 'the well-tempered clavier'}
+    BSON::BSON_RUBY.serialize(doc)
+    bson =  @encoder.serialize(doc)
+    assert_equal doc, BSON::BSON_RUBY.deserialize(bson.to_s)
+  end
+
+  def test_nested_string
+    t0 = Time.now
+    500.times do
+      @encoder.serialize({'doc' => MEDIUM})
+    end
+    t1 = Time.now
+    puts t1 - t0
+  end
+
+  def test_array
+    doc = {'doc' => ['1', '2', '3']}
+    assert_doc_pass(doc)
+    puts "Here's the doc"
+    p doc.class
+    bson = @encoder.serialize(doc)
+    assert_equal bson.to_s, BSON::BSON_RUBY.serialize(doc).to_s
+  end
+
+  def test_number
+    assert_doc_pass({'doc' => 1})
+  end
+
+  def test_object
+    assert_doc_pass({'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}})
+  end
+
+  def test_code
+    @reduce_function = "function (obj, prev) { prev.count += inc_value; }"
+    doc = {"a" => Code.new(@reduce_function, {"a" => 1})}
+    assert_doc_pass(doc)
+  end
+
+  def test_date
+    doc = {'date' => Time.now}
+    d = BSON::BSON_RUBY.serialize(doc)
+    p d.to_s
+    e = BSON::BSON_JAVA.serialize(doc)
+    p e.to_s
+    assert_doc_pass(doc)
+    #bson = @e.serialize(doc)
+    #doc2 = BSON::BSON_CODER.deserialize(bson)
+    # Mongo only stores up to the millisecond
+    #assert_in_delta doc['date'], doc2['date'], 0.001
+  end
+
+#  def test_float
+#    doc = {'a' => 1}
+#    assert_doc_pass(doc)
+#  end
+#
+#  def test_group_cmd
+#    initial = {"c" => 0}
+#    reduce = "function (obj, prev) { prev.c += inc_value; }"
+#    group_command = {
+#        "group" => {
+#          "ns"      => 'col',
+#          "$reduce" => reduce,
+#          "cond"    => {},
+#          "initial" => initial
+#        }
+#      }
+#
+#    assert_doc_pass(group_command)
+#  end
+#
+#  context "Grouping" do
+#    setup do 
+#      @@test.remove
+#      @@test.save("a" => 1)
+#      @@test.save("b" => 1)
+#      @initial = {"count" => 0}
+#      @reduce_function = "function (obj, prev) { prev.count += inc_value; }"
+#    end
+#
+#    should "group results using eval form" do
+#      p @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}))
+#      p @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 2}))
+#      assert_equal 2, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 1}))[0]["count"]
+#      assert_equal 4, @@test.group([], {}, @initial, Code.new(@reduce_function, {"inc_value" => 2}))[0]["count"]
+#    end
+#  end
+#
+#  def test_find_and_modify
+#    @@test << { :a => 1, :processed => false }
+#    @@test << { :a => 2, :processed => false }
+#    @@test << { :a => 3, :processed => false }
+#    p @@test.find.to_a
+#
+#    @@test.find_and_modify(:query => {}, :sort => [['a', -1]], :update => {"$set" => {"processed" => true}})
+#
+#    p @@test.find.to_a
+#    assert @@test.find_one({:a => 3})['processed']
+#  end
+#
+#  def test_invalid_string
+#    require 'iconv'
+#    string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
+#    doc = {'doc' => string}
+#    bson = @encoder.serialize(doc)
+#    assert_equal doc, @encoder.deserialize(bson)
+#  end
+#
+#  def test_null
+#    #doc = {"\x00" => "foo"}
+#    #@encoder.serialize(doc)
+#    @encoder.serialize({"a" => (Regexp.compile "ab\x00c")})
+#  end
+
+#  def test_dbref
+#    oid = ObjectID.new
+#    doc = {}
+#    doc['dbref'] = DBRef.new('namespace', oid)
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    puts doc2.class
+#    puts doc2
+#    assert_equal 'namespace', doc2['dbref'].namespace
+#    assert_equal oid, doc2['dbref'].object_id
+#  end
+
+#  def test_null_character
+#    #assert_raise InvalidDocument do
+#     bson = @encoder.serialize({"\x00" => "a"})
+#     puts bson
+#    #end
+#    puts BSON_RUBY.deserialize(bson)
+#
+#    #assert_raise InvalidDocument do
+#    #  @encoder.serialize({"a" => (Regexp.compile "ab\x00c")})
+#    #end
+#  end
+#
+##  def test_symbol_key
+#    doc     = {:foo => "bar"}
+#    p doc.keys
+#    bson    = @coder.serialize(doc)
+#    new_doc = {"foo" => "bar"}
+#    assert_equal new_doc, @coder.deserialize(bson)
+#  end
+#
+#  
+#  def test_string
+#    assert_doc_pass({'doc' => 'hello, world'})
+#  end
+#
+##
+#  require 'iconv'
+#      def test_invalid_string
+#      require 'iconv'
+#      string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
+#      doc = {'doc' => string}
+#      bson = @coder.serialize(doc)
+#      assert_equal doc, @coder.deserialize(bson)
+#    end
+#
+#
+#  def test_nested_string
+#    assert_doc_pass({'doc' => {'text' => 'hello, world'}})
+#  end
+#
+#  def test_array
+#    assert_doc_pass({'doc' => ['1', '2', '3']})
+#  end
+#
+#  def test_number
+#    assert_doc_pass({'doc' => 1})
+#  end
+#
+#  def test_object
+#    assert_doc_pass({'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}})
+#  end
+#
+#  def test_boolean
+#    assert_doc_pass({'foo' => true})
+#    assert_doc_pass({'foo' => false})
+#  end
+#
+#  def test_nil
+#    assert_doc_pass({'foo' => nil})
+#  end
+#
+#  def test_time
+#    assert_doc_pass({'foo' => Time.now})
+#  end
+#
+#  def test_simple_regex
+#    assert_doc_pass({'foo' => /^a/})
+#  end
+#
+#  def test_regex_with_options
+#    assert_doc_pass({'foo' => /^a/imx})
+#  end
+#
+#  def test_symbol
+#    assert_doc_pass({'foo' => :bar})
+#  end
+#
+#  def test_binary
+#    doc = {'foo' => BSON::Binary.new("ABCDE".unpack("C*"))}
+#    bson = @coder.serialize(doc)
+#    de = @coder.deserialize(bson)
+#    assert_equal doc, de
+#  end
+#
+#  def test_valid_utf8_string
+#    doc = {'doc' => 'aé'}
+#    bson = bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_valid_utf8_key
+#    doc = {'aé' => 'hello'}
+#    bson = bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_number
+#    doc = {'doc' => 41.99}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_int
+#    doc = {'doc' => 42}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"doc" => -5600}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"doc" => 2147483647}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"doc" => -2147483648}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_obj
+#    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#
+#    doc = {"a" => 10, "b" => 20}# {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_oh
+#    oh = BSON::OrderedHash.new
+#    oh["z"] = 10
+#    oh["a"] = 1
+#    bson = BSON::BSON_CODER.serialize(oh)
+#    p bson
+#    assert_equal oh, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+  def test_ordered_hash
+ #   doc = BSON::OrderedHash.new
+ #   doc["b"] = 1
+ #   doc["a"] = 2
+ #   doc["c"] = 3
+ #   doc["d"] = 4
+ #   bson1 = BSON::BSON_CODER.serialize(doc)
+ #   bson2 = BSON::BSON_RUBY.serialize({"b" => 1, "a" => 2, "c" => 3, "d" => 4})
+ #   bson3 = BSON::BSON_RUBY.serialize({"b" => '1', "a" => '2', "c" => '3', "d" => '4'})
+ #   p bson1
+ #   p bson2
+ #   p bson3
+ #   p BSON::BSON_CODER.deserialize(bson3)
+ #   assert_equal doc, BSON::BSON_RUBY.deserialize(bson3)
+  end
+#
+#  def test_object
+#    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+##  def test_oid
+##    doc = {'doc' => ObjectID.new}
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+##  end
+##
+##  def test_array
+##    doc = {'doc' => [1, 2, 'a', 'b']}
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+##  end
+##
+##  def test_invalid_object
+##    doc = {'foo' => Object.new}
+##    assert_raise InvalidDocument do
+##      @coder.serialize(doc)
+##    end
+##
+##    assert_raise InvalidDocument do
+##      @coder.serialize({'date' => Date.today})
+##    end
+##  end
+##
+##
+##  def test_regex
+##    doc = {'doc' => /foobar/i}
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    doc2 = BSON::BSON_CODER.deserialize(bson)
+##    assert_equal doc, doc2
+##
+##    r = doc2['doc']
+##    assert_kind_of Regexp, r
+##
+##    doc = {'doc' => r}
+##    bson_doc = BSON::BSON_CODER.serialize(doc)
+##    doc2 = nil
+##    doc2 = BSON::BSON_CODER.deserialize(bson_doc)
+##    assert_equal doc, doc2
+##  end
+##
+#  def test_boolean
+#    doc = {'doc' => true}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
+#  end
+#
+#  def test_date
+#    doc = {'date' => Time.now}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    # Mongo only stores up to the millisecond
+#    assert_in_delta doc['date'], doc2['date'], 0.001
+#  end
+#
+#  def test_date_returns_as_utc
+#    doc = {'date' => Time.now}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    assert doc2['date'].utc?
+#  end
+#
+##  def test_dbref
+##    oid = ObjectID.new
+##    doc = {}
+##    doc['dbref'] = DBRef.new('namespace', oid)
+##    bson = BSON::BSON_CODER.serialize(doc)
+##    doc2 = BSON::BSON_CODER.deserialize(bson)
+##    assert_equal 'namespace', doc2['dbref'].namespace
+##    assert_equal oid, doc2['dbref'].object_id
+##  end
+##
+#  def test_symbol
+#    doc = {'sym' => :foo}
+#    bson = BSON::BSON_CODER.serialize(doc)
+#    doc2 = BSON::BSON_CODER.deserialize(bson)
+#    assert_equal :foo, doc2['sym']
+#  end
+##
+###  def test_regex_extended
+###    assert_doc_pass({'foo' => /^a/x})
+###  end
+###
+#   def test_object_id
+#     assert_doc_pass({'_id' => BSON::ObjectID.new})
+#   end
+#
+#   def test_where
+#     assert_doc_pass({'$where' => "function() { print('hello'); }"})
+#   end
+#
+#   def test_min_max_keys
+#     assert_doc_pass({'doc' => BSON::MaxKey.new})
+#     assert_doc_pass({'doc' => BSON::MinKey.new})
+#   end
+#
+#   def test_code
+#     code = BSON::Code.new("print('hello')")
+#     code.scope = {:foo => 2}
+#     assert_doc_pass({'doc' => code})
+#   end
+end