mongo 0.19.3 → 0.20

data/lib/mongo/util/byte_buffer.rb

@@ -1,222 +0,0 @@
-# --
-# Copyright (C) 2008-2010 10gen Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ++
-
-# A byte buffer.
-class ByteBuffer
-
-  # Commonly-used integers.
-  INT_LOOKUP = {
-    0    => [0, 0, 0, 0],
-    1    => [1, 0, 0, 0],
-    2    => [2, 0, 0, 0],
-    3    => [3, 0, 0, 0],
-    4    => [4, 0, 0, 0],
-    2001 => [209, 7, 0, 0],
-    2002 => [210, 7, 0, 0],
-    2004 => [212, 7, 0, 0],
-    2005 => [213, 7, 0, 0],
-    2006 => [214, 7, 0, 0]
-  }
-
-  attr_reader :order
-
-  def initialize(initial_data=[])
-    @buf    = initial_data
-    @cursor = @buf.length
-    @order  = :little_endian
-    @int_pack_order    = 'V'
-    @double_pack_order = 'E'
-  end
-
-  if RUBY_VERSION >= '1.9'
-    def self.to_utf8(str)
-      str.encode("utf-8")
-    end
-  else
-    def self.to_utf8(str)
-      begin
-      str.unpack("U*")
-      rescue => ex
-        raise InvalidStringEncoding, "String not valid utf-8: #{str}"
-      end
-      str
-    end
-  end
-
-  def self.serialize_cstr(buf, val)
-    buf.put_array(to_utf8(val.to_s).unpack("C*") + [0])
-  end
-
-  # +endianness+ should be :little_endian or :big_endian. Default is :little_endian
-  def order=(endianness)
-    @order = endianness
-    @int_pack_order = endianness == :little_endian ? 'V' : 'N'
-    @double_pack_order = endianness == :little_endian ? 'E' : 'G'
-  end
-
-  def rewind
-    @cursor = 0
-  end
-
-  def position
-    @cursor
-  end
-
-  def position=(val)
-    @cursor = val
-  end
-
-  def clear
-    @buf = []
-    rewind
-  end
-
-  def size
-    @buf.size
-  end
-  alias_method :length, :size
-
-  # Appends a second ByteBuffer object, +buffer+, to the current buffer.
-  def append!(buffer)
-    @buf = @buf + buffer.to_a
-    self
-  end
-
-  # Prepends a second ByteBuffer object, +buffer+, to the current buffer.
-  def prepend!(buffer)
-    @buf = buffer.to_a + @buf
-    self
-  end
-
-  def put(byte, offset=nil)
-    @cursor = offset if offset
-    @buf[@cursor] = byte
-    @cursor += 1
-  end
-
-  def put_array(array, offset=nil)
-    @cursor = offset if offset
-    @buf[@cursor, array.length] = array
-    @cursor += array.length
-  end
-
-  def put_int(i, offset=nil)
-    unless a = INT_LOOKUP[i]
-      a = []
-      [i].pack(@int_pack_order).each_byte { |b| a << b }
-    end
-    put_array(a, offset)
-  end
-
-  def put_long(i, offset=nil)
-    offset = @cursor unless offset
-    if @int_pack_order == 'N'
-      put_int(i >> 32, offset)
-      put_int(i & 0xffffffff, offset + 4)
-    else
-      put_int(i & 0xffffffff, offset)
-      put_int(i >> 32, offset + 4)
-    end
-  end
-
-  def put_double(d, offset=nil)
-    a = []
-    [d].pack(@double_pack_order).each_byte { |b| a << b }
-    put_array(a, offset)
-  end
-
-  # If +size+ == nil, returns one byte. Else returns array of bytes of length
-  # # +size+.
-  def get(len=nil)
-    one_byte = len.nil?
-    len ||= 1
-    check_read_length(len)
-    start = @cursor
-    @cursor += len
-    if one_byte
-      @buf[start]
-    else
-      if @buf.respond_to? "unpack"
-        @buf[start, len].unpack("C*")
-      else
-        @buf[start, len]
-      end
-    end
-  end
-
-  def get_int
-    check_read_length(4)
-    vals = ""
-    (@cursor..@cursor+3).each { |i| vals << @buf[i].chr }
-    @cursor += 4
-    vals.unpack(@int_pack_order)[0]
-  end
-
-  def get_long
-    i1 = get_int
-    i2 = get_int
-    if @int_pack_order == 'N'
-      (i1 << 32) + i2
-    else
-      (i2 << 32) + i1
-    end
-  end
-
-  def get_double
-    check_read_length(8)
-    vals = ""
-    (@cursor..@cursor+7).each { |i| vals << @buf[i].chr }
-    @cursor += 8
-    vals.unpack(@double_pack_order)[0]
-  end
-
-  def more?
-    @cursor < @buf.size
-  end
-
-  def to_a
-    if @buf.respond_to? "unpack"
-      @buf.unpack("C*")
-    else
-      @buf
-    end
-  end
-
-  def unpack(args)
-    to_a
-  end
-
-  def to_s
-    if @buf.respond_to? :fast_pack
-      @buf.fast_pack
-    elsif @buf.respond_to? "pack"
-      @buf.pack("C*")
-    else
-      @buf
-    end
-  end
-
-  def dump
-    @buf.each_with_index { |c, i| $stderr.puts "#{'%04d' % i}: #{'%02x' % c} #{'%03o' % c} #{'%s' % c.chr} #{'%3d' % c}" }
-  end
-
-  private
-
-  def check_read_length(len)
-    raise "attempt to read past end of buffer" if @cursor + len > @buf.length
-  end
-
-end

data/lib/mongo/util/ordered_hash.rb

@@ -1,140 +0,0 @@
-# --
-# Copyright (C) 2008-2010 10gen Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ++
-
-# A hash in which the order of keys are preserved.
-#
-# Under Ruby 1.9 and greater, this class has no added methods because Ruby's
-# Hash already keeps its keys ordered by order of insertion.
-class OrderedHash < Hash
-
-  def ==(other)
-    begin
-      !other.nil? &&
-        keys == other.keys &&
-        values == other.values
-    rescue
-      false
-    end
-  end
-
-  # We only need the body of this class if the RUBY_VERSION is before 1.9
-  if RUBY_VERSION < '1.9'
-    attr_accessor :ordered_keys
-
-    def self.[] *args
-      oh = OrderedHash.new
-      if Hash === args[0]
-        oh.merge! args[0]
-      elsif (args.size % 2) != 0
-        raise ArgumentError, "odd number of elements for Hash"
-      else
-        0.step(args.size - 1, 2) do |key|
-          value = key + 1
-          oh[args[key]] = args[value]
-        end
-      end
-      oh
-    end
-
-    def initialize(*a, &b)
-      super
-      @ordered_keys = []
-    end
-
-    def keys
-      @ordered_keys || []
-    end
-
-    def []=(key, value)
-      @ordered_keys ||= []
-      @ordered_keys << key unless @ordered_keys.include?(key)
-      super(key, value)
-    end
-
-    def each
-      @ordered_keys ||= []
-      @ordered_keys.each { |k| yield k, self[k] }
-      self
-    end
-    alias :each_pair :each
-
-    def to_a
-      @ordered_keys ||= []
-      @ordered_keys.map { |k| [k, self[k]] }      
-    end
-    
-    def values
-      collect { |k, v| v }
-    end
-
-    def merge(other)
-      oh = self.dup
-      oh.merge!(other)
-      oh
-    end
-
-    def merge!(other)
-      @ordered_keys ||= []
-      @ordered_keys += other.keys # unordered if not an OrderedHash
-      @ordered_keys.uniq!
-      super(other)
-    end
-
-    alias :update :merge!
-
-    def inspect
-      str = '{'
-      str << (@ordered_keys || []).collect { |k| "\"#{k}\"=>#{self.[](k).inspect}" }.join(", ")
-      str << '}'
-    end
-
-    def delete(key, &block)
-      @ordered_keys.delete(key) if @ordered_keys
-      super
-    end
-
-    def delete_if(&block)
-      self.each { |k,v|
-        if yield k, v
-          delete(k)
-        end
-      }
-    end
-
-    def clear
-      super
-      @ordered_keys = []
-    end
-
-    def hash
-      code = 17
-      each_pair do |key, value|
-        code = 37 * code + key.hash
-        code = 37 * code + value.hash
-      end
-      code & 0x7fffffff
-    end
-
-    def eql?(o)
-      if o.instance_of? OrderedHash
-        self.hash == o.hash
-      else
-        false
-      end
-    end
-
-  end
-end

data/test/binary_test.rb

@@ -1,15 +0,0 @@
-# encoding:utf-8
-require 'test/test_helper'
-
-class BinaryTest < Test::Unit::TestCase
-  context "Inspecting" do
-    setup do
-      @data = ("THIS IS BINARY " * 50).unpack("c*")
-    end
-
-    should "not display actual data" do
-      binary = Mongo::Binary.new(@data)
-      assert_equal "<Mongo::Binary:#{binary.object_id}>", binary.inspect
-    end
-  end
-end

data/test/bson_test.rb

@@ -1,459 +0,0 @@
-# encoding:utf-8
-require 'test/test_helper'
-require 'complex'
-require 'bigdecimal'
-require 'rational'
-
-begin
-  require 'active_support/core_ext'
-  require 'active_support/hash_with_indifferent_access'
-  Time.zone = "Pacific Time (US & Canada)"
-  Zone = Time.zone.now
-rescue LoadError
-  warn 'Could not test BSON with HashWithIndifferentAccess.'
-  module ActiveSupport
-    class TimeWithZone
-    end
-  end
-  Zone = ActiveSupport::TimeWithZone.new
-end
-
-class BSONTest < Test::Unit::TestCase
-
-  include Mongo
-
-  def test_string
-    doc = {'doc' => 'hello, world'}
-    bson = bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_valid_utf8_string
-    doc = {'doc' => 'aé'}
-    bson = bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_valid_utf8_key
-    doc = {'aé' => 'hello'}
-    bson = bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_document_length
-    doc = {'name' => 'a' * 5 * 1024 * 1024}
-    assert_raise InvalidDocument do
-      assert BSON.serialize(doc)
-    end
-  end
-
-  # In 1.8 we test that other string encodings raise an exception.
-  # In 1.9 we test that they get auto-converted.
-  if RUBY_VERSION < '1.9'
-    require 'iconv'
-    def test_invalid_string
-      string = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
-      doc = {'doc' => string}
-      assert_raise InvalidStringEncoding do
-        BSON.serialize(doc)
-      end
-    end
-
-    def test_invalid_key
-      key = Iconv.conv('iso-8859-1', 'utf-8', 'aé')
-      doc = {key => 'hello'}
-      assert_raise InvalidStringEncoding do
-        BSON.serialize(doc)
-      end
-    end
-  else
-    def test_non_utf8_string
-      bson = BSON.serialize({'str' => 'aé'.encode('iso-8859-1')})
-      result = BSON.deserialize(bson)['str']
-      assert_equal 'aé', result
-      assert_equal 'UTF-8', result.encoding.name
-    end
-
-    def test_non_utf8_key
-      bson = BSON.serialize({'aé'.encode('iso-8859-1') => 'hello'})
-      assert_equal 'hello', BSON.deserialize(bson)['aé']
-    end
-  end
-
-  def test_code
-    doc = {'$where' => Code.new('this.a.b < this.b')}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_number
-    doc = {'doc' => 41.99}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_int
-    doc = {'doc' => 42}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-
-    doc = {"doc" => -5600}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-
-    doc = {"doc" => 2147483647}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-
-    doc = {"doc" => -2147483648}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_ordered_hash
-    doc = OrderedHash.new
-    doc["b"] = 1
-    doc["a"] = 2
-    doc["c"] = 3
-    doc["d"] = 4
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_object
-    doc = {'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_oid
-    doc = {'doc' => ObjectID.new}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_array
-    doc = {'doc' => [1, 2, 'a', 'b']}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_regex
-    doc = {'doc' => /foobar/i}
-    bson = BSON.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    assert_equal doc, doc2
-
-    r = doc2['doc']
-    assert_kind_of Regexp, r
-
-    r = RegexpOfHolding.new('st', 0, 'zywcab')
-    assert_equal 'zywcab', r.extra_options_str
-
-    doc = {'doc' => r}
-    bson_doc = BSON.serialize(doc)
-    doc2 = nil
-    doc2 = BSON.deserialize(bson_doc)
-    assert_equal doc, doc2
-
-    r = doc2['doc']
-    assert_kind_of RegexpOfHolding, r
-    assert_equal 'abcwyz', r.extra_options_str # must be sorted
-  end
-
-  def test_boolean
-    doc = {'doc' => true}
-    bson = BSON.serialize(doc)
-    assert_equal doc, BSON.deserialize(bson)
-  end
-
-  def test_date
-    doc = {'date' => Time.now}
-    bson = BSON.serialize(doc)
-    doc2 = BSON.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.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    assert doc2['date'].utc?
-  end
-
-  def test_date_before_epoch
-    begin
-      doc = {'date' => Time.utc(1600)}
-      bson = BSON.serialize(doc)
-      doc2 = BSON.deserialize(bson)
-      # Mongo only stores up to the millisecond
-      assert_in_delta doc['date'], doc2['date'], 0.001
-    rescue ArgumentError
-      # some versions of Ruby won't let you create pre-epoch Time instances
-      #
-      # TODO figure out how that will work if somebady has saved data
-      # w/ early dates already and is just querying for it.
-    end
-  end
-
-  def test_exeption_on_using_unsupported_date_class
-    [DateTime.now, Date.today, Zone].each do |invalid_date|
-      doc = {:date => invalid_date}
-      begin
-      bson = BSON.serialize(doc)
-      rescue => e
-      ensure
-        assert_equal InvalidDocument, e.class
-        assert_match /UTC Time/, e.message
-      end
-    end
-  end
-
-  def test_dbref
-    oid = ObjectID.new
-    doc = {}
-    doc['dbref'] = DBRef.new('namespace', oid)
-    bson = BSON.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    assert_equal 'namespace', doc2['dbref'].namespace
-    assert_equal oid, doc2['dbref'].object_id
-  end
-
-  def test_symbol
-    doc = {'sym' => :foo}
-    bson = BSON.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    assert_equal :foo, doc2['sym']
-  end
-
-  def test_binary
-    bin = Binary.new
-    'binstring'.each_byte { |b| bin.put(b) }
-
-    doc = {'bin' => bin}
-    bson = BSON.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    bin2 = doc2['bin']
-    assert_kind_of Binary, bin2
-    assert_equal 'binstring', bin2.to_s
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
-  end
-
-  def test_binary_type
-    bin = Binary.new([1, 2, 3, 4, 5], Binary::SUBTYPE_USER_DEFINED)
-
-    doc = {'bin' => bin}
-    bson = BSON.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    bin2 = doc2['bin']
-    assert_kind_of Binary, bin2
-    assert_equal [1, 2, 3, 4, 5], bin2.to_a
-    assert_equal Binary::SUBTYPE_USER_DEFINED, bin2.subtype
-  end
-
-  def test_binary_byte_buffer
-    bb = ByteBuffer.new
-    5.times { |i| bb.put(i + 1) }
-
-    doc = {'bin' => bb}
-    bson = BSON.serialize(doc)
-    doc2 = BSON.deserialize(bson)
-    bin2 = doc2['bin']
-    assert_kind_of Binary, bin2
-    assert_equal [1, 2, 3, 4, 5], bin2.to_a
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
-  end
-
-  def test_put_id_first
-    val = OrderedHash.new
-    val['not_id'] = 1
-    val['_id'] = 2
-    roundtrip = BSON.deserialize(BSON.serialize(val, false, true).to_a)
-    assert_kind_of OrderedHash, roundtrip
-    assert_equal '_id', roundtrip.keys.first
-
-    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
-    roundtrip = BSON.deserialize(BSON.serialize(val, false, true).to_a)
-    assert_kind_of OrderedHash, roundtrip
-    assert_equal '_id', roundtrip.keys.first
-  end
-
-  def test_nil_id
-    doc = {"_id" => nil}
-    assert_equal doc, BSON.deserialize(bson = BSON.serialize(doc, false, true).to_a)
-  end
-
-  def test_timestamp
-    val = {"test" => [4, 20]}
-    assert_equal val, BSON.deserialize([0x13, 0x00, 0x00, 0x00,
-                                      0x11, 0x74, 0x65, 0x73,
-                                      0x74, 0x00, 0x04, 0x00,
-                                      0x00, 0x00, 0x14, 0x00,
-                                      0x00, 0x00, 0x00])
-  end
-
-  def test_overflow
-    doc = {"x" => 2**75}
-    assert_raise RangeError do
-      bson = BSON.serialize(doc)
-    end
-
-    doc = {"x" => 9223372036854775}
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-
-    doc = {"x" => 9223372036854775807}
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-
-    doc["x"] = doc["x"] + 1
-    assert_raise RangeError do
-      bson = BSON.serialize(doc)
-    end
-
-    doc = {"x" => -9223372036854775}
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-
-    doc = {"x" => -9223372036854775808}
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-
-    doc["x"] = doc["x"] - 1
-    assert_raise RangeError do
-      bson = BSON.serialize(doc)
-    end
-  end
-
-  def test_invalid_numeric_types
-    [BigDecimal.new("1.0"), Complex(0, 1), Rational(2, 3)].each do |type|
-      doc = {"x" => type}
-      begin
-        BSON.serialize(doc)
-      rescue => e
-      ensure
-        assert_equal InvalidDocument, e.class
-        assert_match /Cannot serialize/, e.message
-      end
-    end
-  end
-
-  def test_do_not_change_original_object
-    val = OrderedHash.new
-    val['not_id'] = 1
-    val['_id'] = 2
-    assert val.keys.include?('_id')
-    BSON.serialize(val)
-    assert val.keys.include?('_id')
-
-    val = {'a' => 'foo', 'b' => 'bar', :_id => 42, 'z' => 'hello'}
-    assert val.keys.include?(:_id)
-    BSON.serialize(val)
-    assert val.keys.include?(:_id)
-  end
-
-  # note we only test for _id here because in the general case we will
-  # write duplicates for :key and "key". _id is a special case because
-  # we call has_key? to check for it's existance rather than just iterating
-  # over it like we do for the rest of the keys. thus, things like
-  # HashWithIndifferentAccess can cause problems for _id but not for other
-  # keys. rather than require rails to test with HWIA directly, we do this
-  # somewhat hacky test.
-  def test_no_duplicate_id
-    dup = {"_id" => "foo", :_id => "foo"}
-    one = {"_id" => "foo"}
-
-    assert_equal BSON.serialize(one).to_a, BSON.serialize(dup).to_a
-  end
-
-  def test_no_duplicate_id_when_moving_id
-    dup = {"_id" => "foo", :_id => "foo"}
-    one = {:_id => "foo"}
-
-    assert_equal BSON.serialize(one, false, true).to_s, BSON.serialize(dup, false, true).to_s
-  end
-
-  def test_null_character
-    doc = {"a" => "\x00"}
-
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-
-    assert_raise InvalidDocument do
-      BSON.serialize({"\x00" => "a"})
-    end
-
-    assert_raise InvalidDocument do
-      BSON.serialize({"a" => (Regexp.compile "ab\x00c")})
-    end
-  end
-
-  def test_max_key
-    doc = {"a" => MaxKey.new}
-
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-  end
-
-  def test_min_key
-    doc = {"a" => MinKey.new}
-
-    assert_equal doc, BSON.deserialize(BSON.serialize(doc).to_a)
-  end
-
-  def test_invalid_object
-    o = Object.new
-    assert_raise InvalidDocument do
-      BSON.serialize({:foo => o})
-    end
-
-    assert_raise InvalidDocument do
-      BSON.serialize({:foo => Date.today})
-    end
-  end
-
-  def test_move_id
-    a = OrderedHash.new
-    a['text'] = 'abc'
-    a['key'] = 'abc'
-    a['_id']  = 1
-
-
-    assert_equal ")\000\000\000\020_id\000\001\000\000\000\002text" +
-                 "\000\004\000\000\000abc\000\002key\000\004\000\000\000abc\000\000",
-                 BSON.serialize(a, false, true).to_s
-    assert_equal ")\000\000\000\002text\000\004\000\000\000abc\000\002key" +
-                 "\000\004\000\000\000abc\000\020_id\000\001\000\000\000\000",
-                 BSON.serialize(a, false, false).to_s
-  end
-
-  def test_move_id_with_nested_doc
-    b = OrderedHash.new
-    b['text'] = 'abc'
-    b['_id']   = 2
-    c = OrderedHash.new
-    c['text'] = 'abc'
-    c['hash'] = b
-    c['_id']  = 3
-    assert_equal ">\000\000\000\020_id\000\003\000\000\000\002text" +
-                 "\000\004\000\000\000abc\000\003hash\000\034\000\000" +
-                 "\000\002text\000\004\000\000\000abc\000\020_id\000\002\000\000\000\000\000",
-                 BSON.serialize(c, false, true).to_s
-    assert_equal ">\000\000\000\002text\000\004\000\000\000abc\000\003hash" +
-                 "\000\034\000\000\000\002text\000\004\000\000\000abc\000\020_id" +
-                 "\000\002\000\000\000\000\020_id\000\003\000\000\000\000",
-                 BSON.serialize(c, false, false).to_s
-  end
-
-  if defined?(HashWithIndifferentAccess)
-    def test_keep_id_with_hash_with_indifferent_access
-      doc = HashWithIndifferentAccess.new
-      embedded = HashWithIndifferentAccess.new
-      embedded['_id'] = ObjectID.new
-      doc['_id']      = ObjectID.new
-      doc['embedded'] = [embedded]
-      BSON.serialize(doc, false, true).to_a
-      assert doc.has_key?("_id")
-      assert doc['embedded'][0].has_key?("_id")
-
-      doc['_id'] = ObjectID.new
-      BSON.serialize(doc, false, true).to_a
-      assert doc.has_key?("_id")
-    end
-  end
-end