bson 1.0.9 → 1.1

data/test/mongo_bson/byte_buffer_test.rb

@@ -1,190 +0,0 @@
-# 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/mongo_bson/jruby_bson_test.rb

@@ -1,227 +0,0 @@
-# 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' => 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
-}
-
-
-
-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 BSON
-  
-  def setup
-    @coder = BSON::BSON_CODER
-  end
-
-  def assert_doc_pass(doc)
-    bson = @coder.serialize(doc)
-    assert_equal doc, @coder.deserialize(bson)
-  end
-
-  def test_string
-    assert_doc_pass({'doc' => 'hello, world'})
-  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_object
-    assert_doc_pass({'doc' => {'age' => 42, 'name' => 'Spongebob', 'shoe_size' => 9.5}})
-  end
-
-  def test_boolean
-    doc = {'foo' => true}
-    bson = @coder.serialize(doc)
-    assert_equal doc, @coder.deserialize(bson)
-  end
-
-  def test_nil
-    assert_doc_pass({'foo' => nil})
-  end
-
-  def test_time
-    assert_doc_pass({'foo' => Time.now})
-  end
-
-  def test_regex
-    assert_doc_pass({'foo' => /^a/im})
-  end
-
-  def test_symbol
-    assert_doc_pass({'foo' => :bar})
-  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_ordered_hash
-    doc = BSON::OrderedHash.new
-    doc["b"] = 1
-    doc["a"] = 2
-    doc["c"] = 3
-    doc["d"] = 4
-    bson = BSON::BSON_CODER.serialize(doc)
-    p bson
-    assert_equal doc, BSON::BSON_CODER.deserialize(bson)
-  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_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
-end

data/test/mongo_bson/jruby_encode_test.rb

@@ -1,396 +0,0 @@
-# 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
-    con = Mongo::Connection.new
-    db = con['mongo-ruby-test']
-    @@test = db['col']
-    @@test.remove
-  end
-
-  def assert_doc_pass(doc)
-    bson = @encoder.serialize(doc)
-    puts "#{doc.inspect} serializes to #{bson.inspect}"
-    p bson.to_a
-
-    assert_equal doc, @encoder.deserialize(bson)
-  end
-
-  def test_code
-    @reduce_function = "1"#function (obj, prev) { prev.count += inc_value; }"
-    doc = {"a" => Code.new(@reduce_function, {"a" => 1})}
-    assert_doc_pass(doc)
-  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