bson 1.0.7 → 1.0.9

data/lib/bson.rb

@@ -2,10 +2,10 @@
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-MINIMUM_BSON_EXT_VERSION = "1.0.7"
+MINIMUM_BSON_EXT_VERSION = "1.0.9"
 
 module BSON
-  VERSION = "1.0.7"
+  VERSION = "1.0.9"
   def self.serialize(obj, check_keys=false, move_id=false)
     BSON_CODER.serialize(obj, check_keys, move_id)
   end

data/lib/bson/bson_c.rb

@@ -25,13 +25,7 @@ module BSON
     end
 
     def self.deserialize(buf=nil)
-      if buf.is_a? String
-        buf = ByteBuffer.new(buf.unpack("C*")) if buf
-      else
-        buf = ByteBuffer.new(buf.to_a) if buf
-      end
-      buf.rewind
-      CBson.deserialize(buf.to_s)
+      CBson.deserialize(ByteBuffer.new(buf).to_s)
     end
 
   end

data/lib/bson/bson_ruby.rb

@@ -47,22 +47,29 @@ module BSON
     end
 
     if RUBY_VERSION >= '1.9'
-      def self.to_utf8(str)
-        str.encode("utf-8")
+      NULL_BYTE       = "\0".force_encoding('binary').freeze
+      UTF8_ENCODING   = Encoding.find('utf-8')
+      BINARY_ENCODING = Encoding.find('binary')
+      
+      def self.to_utf8_binary(str)
+        str.encode(UTF8_ENCODING).force_encoding(BINARY_ENCODING)
       end
     else
-      def self.to_utf8(str)
+      NULL_BYTE = "\0"
+      
+      def self.to_utf8_binary(str)
         begin
           str.unpack("U*")
         rescue => ex
-          raise InvalidStringEncoding, "String not valid utf-8: #{str}"
+          raise InvalidStringEncoding, "String not valid utf-8: #{str.inspect}"
         end
         str
       end
     end
 
     def self.serialize_cstr(buf, val)
-      buf.put_array(to_utf8(val.to_s).unpack("C*") << 0)
+      buf.put_binary(to_utf8_binary(val.to_s))
+      buf.put_binary(NULL_BYTE)
     end
 
     def self.serialize_key(buf, key)
@@ -271,7 +278,6 @@ module BSON
 
     def deserialize_date_data(buf)
       unsigned = buf.get_long()
-      # see note for deserialize_number_long_data below
       milliseconds = unsigned >= 2 ** 64 / 2 ? unsigned - 2**64 : unsigned
       Time.at(milliseconds.to_f / 1000.0).utc # at() takes fractional seconds
     end
@@ -285,14 +291,11 @@ module BSON
     end
 
     def deserialize_number_int_data(buf)
-      # sometimes ruby makes me angry... why would the same code pack as signed
-      # but unpack as unsigned
       unsigned = buf.get_int
       unsigned >= 2**32 / 2 ? unsigned - 2**32 : unsigned
     end
 
     def deserialize_number_long_data(buf)
-      # same note as above applies here...
       unsigned = buf.get_long
       unsigned >= 2 ** 64 / 2 ? unsigned - 2**64 : unsigned
     end

data/lib/bson/byte_buffer.rb

@@ -20,47 +20,48 @@
 module BSON
   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
+    def initialize(initial_data="")
+      if initial_data.is_a?(String)
+        if initial_data.respond_to?(:force_encoding)
+          @str = initial_data.force_encoding('binary')
+        else
+          @str = initial_data
+        end
+      else
+        @str = initial_data.pack('C*')
+      end
+      @cursor = @str.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")
+      NULL_BYTE       = "\0".force_encoding('binary').freeze
+      UTF8_ENCODING   = Encoding.find('utf-8')
+      BINARY_ENCODING = Encoding.find('binary')
+      
+      def self.to_utf8_binary(str)
+        str.encode(UTF8_ENCODING).force_encoding(BINARY_ENCODING)
       end
     else
-      def self.to_utf8(str)
+      NULL_BYTE = "\0"
+      
+      def self.to_utf8_binary(str)
         begin
         str.unpack("U*")
         rescue => ex
-          raise InvalidStringEncoding, "String not valid utf-8: #{str}"
+          raise InvalidStringEncoding, "String not valid utf-8: #{str.inspect}"
         end
         str
       end
     end
 
     def self.serialize_cstr(buf, val)
-      buf.put_array(to_utf8(val.to_s).unpack("C*") + [0])
+      buf.append!(to_utf8_binary(val.to_s))
+      buf.append!(NULL_BYTE)
     end
 
     # +endianness+ should be :little_endian or :big_endian. Default is :little_endian
@@ -83,45 +84,73 @@ module BSON
     end
 
     def clear
-      @buf = []
+      @str = ""
+      @str.force_encoding('binary') if @str.respond_to?(:force_encoding)
       rewind
     end
 
     def size
-      @buf.size
+      @str.size
     end
     alias_method :length, :size
 
     # Appends a second ByteBuffer object, +buffer+, to the current buffer.
     def append!(buffer)
-      @buf = @buf + buffer.to_a
+      @str << buffer.to_s
       self
     end
 
     # Prepends a second ByteBuffer object, +buffer+, to the current buffer.
     def prepend!(buffer)
-      @buf = buffer.to_a + @buf
+      @str = buffer.to_s + @str
       self
     end
 
     def put(byte, offset=nil)
       @cursor = offset if offset
-      @buf[@cursor] = byte
+      if more?
+        @str[@cursor] = chr(byte)
+      else
+        ensure_length(@cursor)
+        @str << chr(byte)
+      end
       @cursor += 1
     end
-
+    
+    def put_binary(data, offset=nil)
+      @cursor = offset if offset
+      if defined?(BINARY_ENCODING)
+        data = data.dup.force_encoding(BINARY_ENCODING)
+      end
+      if more?
+        @str[@cursor, data.length] = data
+      else
+        ensure_length(@cursor)
+        @str << data
+      end
+      @cursor += data.length
+    end
+    
     def put_array(array, offset=nil)
       @cursor = offset if offset
-      @buf[@cursor, array.length] = array
+      if more?
+        @str[@cursor, array.length] = array.pack("C*")
+      else
+        ensure_length(@cursor)
+        @str << array.pack("C*")
+      end
       @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 }
+      @cursor = offset if offset
+      if more?
+        @str[@cursor, 4] = [i].pack(@int_pack_order)
+      else
+        ensure_length(@cursor)
+        @str << [i].pack(@int_pack_order)
       end
-      put_array(a, offset)
+      @cursor += 4
     end
 
     def put_long(i, offset=nil)
@@ -143,27 +172,37 @@ module BSON
 
     # 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*")
+    if "x"[0].is_a?(Integer)
+      def get(len=nil)
+        one_byte = len.nil?
+        len ||= 1
+        check_read_length(len)
+        start = @cursor
+        @cursor += len
+        if one_byte
+          @str[start]
         else
-          @buf[start, len]
+          @str[start, len].unpack("C*")
+        end
+      end
+    else
+      def get(len=nil)
+        one_byte = len.nil?
+        len ||= 1
+        check_read_length(len)
+        start = @cursor
+        @cursor += len
+        if one_byte
+          @str[start, 1].ord
+        else
+          @str[start, len].unpack("C*")
         end
       end
     end
 
     def get_int
       check_read_length(4)
-      vals = ""
-      (@cursor..@cursor+3).each { |i| vals << @buf[i].chr }
+      vals = @str[@cursor..@cursor+3]
       @cursor += 4
       vals.unpack(@int_pack_order)[0]
     end
@@ -180,22 +219,17 @@ module BSON
 
     def get_double
       check_read_length(8)
-      vals = ""
-      (@cursor..@cursor+7).each { |i| vals << @buf[i].chr }
+      vals = @str[@cursor..@cursor+7]
       @cursor += 8
       vals.unpack(@double_pack_order)[0]
     end
 
     def more?
-      @cursor < @buf.size
+      @cursor < @str.size
     end
 
     def to_a
-      if @buf.respond_to? "unpack"
-        @buf.unpack("C*")
-      else
-        @buf
-      end
+      @str.unpack("C*")
     end
 
     def unpack(args)
@@ -203,23 +237,35 @@ module BSON
     end
 
     def to_s
-      if @buf.respond_to? :fast_pack
-        @buf.fast_pack
-      elsif @buf.respond_to? "pack"
-        @buf.pack("C*")
-      else
-        @buf
-      end
+      @str
     end
 
     def dump
-      @buf.each_with_index { |c, i| $stderr.puts "#{'%04d' % i}: #{'%02x' % c} #{'%03o' % c} #{'%s' % c.chr} #{'%3d' % c}" }
+      i = 0
+      @str.each_byte do |c, i|
+        $stderr.puts "#{'%04d' % i}: #{'%02x' % c} #{'%03o' % c} #{'%s' % c.chr} #{'%3d' % c}"
+        i += 1
+      end
     end
 
     private
 
+    def ensure_length(length)
+      if @str.size < length
+        @str << NULL_BYTE * (length - @str.size)
+      end
+    end
+    
+    def chr(byte)
+      if byte < 0
+        [byte].pack('c')
+      else
+        byte.chr
+      end
+    end
+    
     def check_read_length(len)
-      raise "attempt to read past end of buffer" if @cursor + len > @buf.length
+      raise "attempt to read past end of buffer" if @cursor + len > @str.length
     end
 
   end

data/lib/bson/ordered_hash.rb

@@ -20,7 +20,6 @@
 #
 # 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.
-require 'set'
 
 module BSON
   class OrderedHash < Hash
@@ -60,7 +59,6 @@ module BSON
       def initialize(*a, &b)
         super
         @ordered_keys = []
-        @ordered_set = Set.new
       end
 
       def keys
@@ -69,10 +67,8 @@ module BSON
 
       def []=(key, value)
         @ordered_keys ||= []
-        @ordered_set ||= Set.new
-        unless @ordered_set.member?(key)
+        unless has_key?(key)
           @ordered_keys << key
-          @ordered_set.add(key)
         end
         super(key, value)
       end
@@ -103,7 +99,6 @@ module BSON
         @ordered_keys ||= []
         @ordered_keys += other.keys # unordered if not an BSON::OrderedHash
         @ordered_keys.uniq!
-        @ordered_set = Set.new(@ordered_keys)
         super(other)
       end
 
@@ -117,7 +112,6 @@ module BSON
 
       def delete(key, &block)
         @ordered_keys.delete(key) if @ordered_keys
-        @ordered_set.delete(key) if @ordered_set
         super
       end
 
@@ -137,7 +131,6 @@ module BSON
 
       def clear
         super
-        @ordered_set.clear
         @ordered_keys = []
       end
 

data/lib/bson/types/binary.rb

@@ -37,14 +37,13 @@ module BSON
 
     # Create a buffer for storing binary data in MongoDB.
     #
-    # @param [Array, String] data to story as BSON binary. If a string is given, the value will be
-    #   concerted to an array of bytes using String#unpack("c*").
+    # @param [Array, String] data to story as BSON binary. If a string is given, the on
+    #   Ruby 1.9 it will be forced to the binary encoding.
     # @param [Fixnum] one of four values specifying a BSON binary subtype. Possible values are
     #   SUBTYPE_BYTES, SUBTYPE_UUID, SUBTYPE_MD5, and SUBTYPE_USER_DEFINED.
     #
     # @see http://www.mongodb.org/display/DOCS/BSON#BSON-noteondatabinary BSON binary subtypes.
     def initialize(data=[], subtype=SUBTYPE_BYTES)
-      data = data.unpack("c*") if data.is_a?(String)
       super(data)
       @subtype = subtype
     end

data/test/mongo_bson/basic_test.rb

@@ -1,5 +1,5 @@
 # encoding:utf-8
-require 'test/test_helper'
+require './test/test_helper'
 require 'complex'
 require 'bigdecimal'
 require 'rational'

data/test/mongo_bson/binary_test.rb

@@ -1,5 +1,5 @@
 # encoding:utf-8
-require 'test/test_helper'
+require './test/test_helper'
 
 class BinaryTest < Test::Unit::TestCase
   context "Inspecting" do

data/test/mongo_bson/bson_test.rb

@@ -1,5 +1,5 @@
 # encoding:utf-8
-require 'test/test_helper'
+require './test/test_helper'
 require 'complex'
 require 'bigdecimal'
 require 'rational'
@@ -191,7 +191,7 @@ class BSONTest < Test::Unit::TestCase
   end
 
   def test_oid
-    doc = {'doc' => ObjectID.new}
+    doc = {'doc' => ObjectId.new}
     bson = BSON::BSON_CODER.serialize(doc)
     assert_equal doc, BSON::BSON_CODER.deserialize(bson)
   end
@@ -270,7 +270,7 @@ class BSONTest < Test::Unit::TestCase
   end
 
   def test_dbref
-    oid = ObjectID.new
+    oid = ObjectId.new
     doc = {}
     doc['dbref'] = DBRef.new('namespace', oid)
     bson = BSON::BSON_CODER.serialize(doc)
@@ -528,14 +528,14 @@ class BSONTest < Test::Unit::TestCase
   def test_keep_id_with_hash_with_indifferent_access
     doc = HashWithIndifferentAccess.new
     embedded = HashWithIndifferentAccess.new
-    embedded['_id'] = ObjectID.new
-    doc['_id']      = ObjectID.new
+    embedded['_id'] = ObjectId.new
+    doc['_id']      = ObjectId.new
     doc['embedded'] = [embedded]
     BSON::BSON_CODER.serialize(doc, false, true).to_a
     assert doc.has_key?("_id")
     assert doc['embedded'][0].has_key?("_id")
 
-    doc['_id'] = ObjectID.new
+    doc['_id'] = ObjectId.new
     BSON::BSON_CODER.serialize(doc, false, true).to_a
     assert doc.has_key?("_id")
   end

data/test/mongo_bson/byte_buffer_test.rb

@@ -1,4 +1,5 @@
-require 'test/test_helper'
+# encoding: binary
+require './test/test_helper'
 
 class ByteBufferTest < Test::Unit::TestCase
   include BSON
@@ -6,6 +7,13 @@ class ByteBufferTest < Test::Unit::TestCase
   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])
@@ -25,10 +33,6 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal [], @buf.get(0)
   end
 
-  def test_empty
-    assert_equal 0, @buf.length
-  end
-
   def test_length
     @buf.put_int 3
     assert_equal 4, @buf.length
@@ -54,7 +58,80 @@ class ByteBufferTest < Test::Unit::TestCase
     @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
@@ -78,5 +155,36 @@ class ByteBufferTest < Test::Unit::TestCase
     @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/mongo_bson/jruby_encode_test.rb

@@ -34,7 +34,7 @@ LARGE = {
 
 class BSONTest < Test::Unit::TestCase
   include BSON
-  
+
   def setup
     @encoder = BSON::BSON_CODER
     con = Mongo::Connection.new
@@ -106,14 +106,14 @@ class BSONTest < Test::Unit::TestCase
 #    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_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)
@@ -152,9 +152,11 @@ class BSONTest < Test::Unit::TestCase
 #    assert_equal new_doc, @coder.deserialize(bson)
 #  end
 #
-#  def test_string
-#    assert_doc_pass({'doc' => 'hello, world'})
-#  end
+  
+  def test_string
+    assert_doc_pass({'doc' => 'hello, world'})
+  end
+
 ##
 #  require 'iconv'
 #      def test_invalid_string

data/test/mongo_bson/json_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require './test/test_helper'
 require 'rubygems'
 require 'json'
 
@@ -8,7 +8,7 @@ class JSONTest < Test::Unit::TestCase
   include BSON
 
   def test_object_id_as_json
-    id = ObjectID.new
+    id = ObjectId.new
     obj = {'_id' => id}
     assert_equal "{\"_id\":{\"$oid\": \"#{id.to_s}\"}}", obj.to_json
   end

data/test/mongo_bson/object_id_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require './test/test_helper'
 require 'rubygems'
 require 'json'
 

data/test/mongo_bson/ordered_hash_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require './test/test_helper'
 
 class OrderedHashTest < Test::Unit::TestCase
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bson
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 5
   prerelease: false
   segments: 
   - 1
   - 0
-  - 7
-  version: 1.0.7
+  - 9
+  version: 1.0.9
 platform: ruby
 authors: 
 - Jim Menard
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-28 00:00:00 -04:00
+date: 2010-09-20 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -56,7 +56,6 @@ files:
 - test/mongo_bson/jruby_encode_test.rb
 - test/mongo_bson/json_test.rb
 - test/mongo_bson/object_id_test.rb
-- test/mongo_bson/objectid_test.rb
 - test/mongo_bson/ordered_hash_test.rb
 has_rdoc: true
 homepage: http://www.mongodb.org
@@ -101,5 +100,4 @@ test_files:
 - test/mongo_bson/jruby_encode_test.rb
 - test/mongo_bson/json_test.rb
 - test/mongo_bson/object_id_test.rb
-- test/mongo_bson/objectid_test.rb
 - test/mongo_bson/ordered_hash_test.rb

data/test/mongo_bson/objectid_test.rb

@@ -1,132 +0,0 @@
-require 'test/test_helper'
-require 'rubygems'
-require 'json'
-
-class ObjectIDTest < Test::Unit::TestCase
-
-  include Mongo
-  include BSON
-
-  def setup
-    @o = ObjectID.new
-  end
-
-  def test_hashcode
-    assert_equal @o.instance_variable_get(:@data).hash, @o.hash
-  end
-
-  def test_array_uniq_for_equilavent_ids
-    a = ObjectID.new('123')
-    b = ObjectID.new('123')
-    assert_equal a, b
-    assert_equal 1, [a, b].uniq.size
-  end
-
-  def test_create_pk_method
-    doc = {:name => 'Mongo'}
-    doc = ObjectID.create_pk(doc)
-    assert doc[:_id]
-
-    doc = {:name => 'Mongo', :_id => '12345'}
-    doc = ObjectID.create_pk(doc)
-    assert_equal '12345', doc[:_id]
-  end
-
-  def test_different
-    a = ObjectID.new
-    b = ObjectID.new
-    assert_not_equal a.to_a, b.to_a
-    assert_not_equal a, b
-  end
-
-  def test_eql?
-    o2 = ObjectID.new(@o.to_a)
-    assert_equal @o, o2
-  end
-
-  def test_to_s
-    s = @o.to_s
-    assert_equal 24, s.length
-    s =~ /^([0-9a-f]+)$/
-    assert_equal 24, $1.length
-  end
-
-  def test_method
-    assert_equal ObjectID.from_string(@o.to_s), BSON::ObjectID(@o.to_s)
-  end
-
-  def test_inspect
-    assert_equal "BSON::ObjectID('#{@o.to_s}')", @o.inspect
-  end
-
-  def test_save_and_restore
-    host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
-    port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
-    db = Connection.new(host, port).db(MONGO_TEST_DB)
-    coll = db.collection('test')
-
-    coll.remove
-    coll << {'a' => 1, '_id' => @o}
-
-    row = coll.find().collect.first
-    assert_equal 1, row['a']
-    assert_equal @o, row['_id']
-  end
-
-  def test_from_string
-    hex_str = @o.to_s
-    o2 = ObjectID.from_string(hex_str)
-    assert_equal hex_str, o2.to_s
-    assert_equal @o, o2
-    assert_equal @o.to_s, o2.to_s
-  end
-
-  def test_illegal_from_string
-    assert_raise InvalidObjectID do 
-      ObjectID.from_string("")
-    end
-  end
-
-  def test_legal
-    assert !ObjectID.legal?(nil)
-    assert !ObjectID.legal?("fred")
-    assert !ObjectID.legal?("0000")
-    assert !ObjectID.legal?('000102030405060708090A0')
-    assert ObjectID.legal?('000102030405060708090A0B')
-    assert ObjectID.legal?('abcdefABCDEF123456789012')
-    assert !ObjectID.legal?('abcdefABCDEF12345678901x')
-  end
-
-  def test_from_string_leading_zeroes
-    hex_str = '000000000000000000000000'
-    o = ObjectID.from_string(hex_str)
-    assert_equal hex_str, o.to_s
-  end
-
-  def test_byte_order
-    hex_str = '000102030405060708090A0B'
-    o = ObjectID.from_string(hex_str)
-    assert_equal [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b], o.to_a
-  end
-
-  def test_generation_time
-    time = Time.now
-    id   = ObjectID.new
-    generated_time = id.generation_time
-
-    assert_in_delta time.to_i, generated_time.to_i, 2
-    assert_equal "UTC", generated_time.zone
-  end
-
-  def test_from_time
-    time = Time.now.utc
-    id   = ObjectID.from_time(time)
-
-    assert_equal time.to_i, id.generation_time.to_i
-  end
-
-  def test_json
-    id = ObjectID.new
-    assert_equal "{\"$oid\": \"#{id}\"}", id.to_json
-  end
-end