Merge lp:~miki-tebeka/mgo/string-compile into lp:~niemeyer/mgo/trunk

[tebeka]

Fix compilation error with current go head (e3cd47e9748d)

[Gustavo Niemeyer (niemeyer)]

Please check out the diff from this branch (below in the merge proposal). Looks like quite a few things have changed unintendedly.

Also, please note that mgo will follow the stable release of Go. Once these changes make into the stable release, mgo will be immediately changed accordingly.

We'll likely need a way to enable people to use mgo with the head, though. I've been thinking about some convention around that. Please pop up in the mailing list to talk about this if you have ideas.

[tebeka (miki-tebeka)]

Greetings,

> Please check out the diff from this branch (below in the merge proposal). Looks like quite a few things have changed unintendedly.
This it a patch to gobson, I did a mistake when creating the branch.
Attached the right patch.

> Also, please note that mgo will follow the stable release of Go.  Once these changes make into the stable release, mgo will be immediately changed accordingly.
I guessed so and it's the right thing to do. I run from tip since I mostly play.

All the best,
--
Miki

Unmerged revisions

29. By tebeka on 2011-07-28

Compile with go head

28. By Gustavo Niemeyer on 2011-07-16

Some inlining and tweaks for decoding performance.

27. By Gustavo Niemeyer on 2011-06-24

os.ErrorString => os.NewError

26. By Gustavo Niemeyer on 2011-05-12

Raw.Unmarshal and "/s" support.

25. By Gustavo Niemeyer on 2011-04-29

Updated to current weekly and binary array support.

24. By Gustavo Niemeyer on 2011-04-24

Better handling of pointers.

23. By Gustavo Niemeyer on 2011-04-18

Added Raw type.

22. By Gustavo Niemeyer on 2011-04-16

Encode (u)int64 as int32 if the value fits.

21. By Gustavo Niemeyer on 2011-04-16

s/Milliseconds/Timestamp/ and use ns. Added Now().

20. By Gustavo Niemeyer on 2011-04-15

Ported to current weekly.

=== added file 'LICENSE'
--- LICENSE	1970-01-01 00:00:00 +0000
+++ LICENSE	2011-07-28 17:08:30 +0000
@@ -0,0 +1,29 @@
+gobson - BSON library for Go.
+
+Copyright (c) 2010-2011 - Gustavo Niemeyer <[e-mail]>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
=== renamed file 'LICENSE' => 'LICENSE.moved'
=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2011-07-28 17:08:30 +0000
@@ -0,0 +1,22 @@
+include $(GOROOT)/src/Make.inc
+
+TARG=launchpad.net/gobson/bson
+
+GOFILES=\
+	gobson.go\
+	encode.go\
+	decode.go\
+
+include $(GOROOT)/src/Make.pkg
+
+GOFMT=gofmt
+BADFMT=$(shell $(GOFMT) -l $(GOFILES) $(wildcard *_test.go) 2> /dev/null)
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
 
=== renamed file 'Makefile' => 'Makefile.moved'
=== added file 'decode.go'
--- decode.go	1970-01-01 00:00:00 +0000
+++ decode.go	2011-07-28 17:08:30 +0000
@@ -0,0 +1,596 @@
+// gobson - BSON library for Go.
+// 
+// Copyright (c) 2010-2011 - Gustavo Niemeyer <[e-mail]>
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//       this list of conditions and the following disclaimer in the documentation
+//       and/or other materials provided with the distribution.
+//     * Neither the name of the copyright holder nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package bson
+
+import (
+	"reflect"
+	"math"
+	"fmt"
+)
+
+type decoder struct {
+	in []byte
+	i  int
+}
+
+// --------------------------------------------------------------------------
+// Some helper functions.
+
+func corrupted() {
+	panic("Document is corrupted")
+}
+
+func zeroNilPtr(v reflect.Value) (changed bool) {
+	if v.Kind() == reflect.Ptr && v.IsNil() {
+		v.Set(reflect.New(v.Type().Elem()))
+		return true
+	}
+	return false
+}
+
+func settableValueOf(i interface{}) reflect.Value {
+	v := reflect.ValueOf(i)
+	sv := reflect.New(v.Type()).Elem()
+	sv.Set(v)
+	return sv
+}
+
+// --------------------------------------------------------------------------
+// Unmarshaling of documents.
+
+func (d *decoder) readDocTo(out reflect.Value) {
+	var elemType reflect.Type
+	outt := out.Type()
+	outk := outt.Kind()
+
+	for {
+		if outk == reflect.Ptr && out.IsNil() {
+			out.Set(reflect.New(outt.Elem()))
+		}
+		if setter, ok := out.Interface().(Setter); ok {
+			setter.SetBSON(d.readDocD())
+			return
+		}
+		if outk == reflect.Ptr {
+			out = out.Elem()
+			outt = out.Type()
+			outk = out.Kind()
+			continue
+		}
+		break
+	}
+
+	var fieldsMap map[string]fieldInfo
+	start := d.i
+
+	switch outk {
+	case reflect.Interface:
+		if !out.IsNil() {
+			panic("Found non-nil interface. Please contact the developers.")
+		}
+		mv := reflect.ValueOf(make(M))
+		out.Set(mv)
+		out = mv
+		outt = out.Type()
+		outk = outt.Kind()
+		fallthrough
+	case reflect.Map:
+		if outt.Key().Kind() != reflect.String {
+			panic("BSON map must have string keys. Got: " + outt.String())
+		}
+		elemType = outt.Elem()
+		if out.IsNil() {
+			out.Set(reflect.MakeMap(out.Type()))
+		}
+	case reflect.Struct:
+		if outt != typeRaw {
+			fields, err := getStructFields(out.Type())
+			if err != nil {
+				panic(err)
+			}
+			fieldsMap = fields.Map
+		}
+	default:
+		panic("TESTME:" + reflect.ValueOf(out).Type().String())
+	}
+
+	end := d.i - 4 + int(d.readInt32())
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	for d.in[d.i] != '\x00' {
+		kind := d.readByte()
+		name := d.readCStr()
+		if d.i >= end {
+			corrupted()
+		}
+
+		switch outk {
+		case reflect.Map:
+			e := reflect.New(elemType).Elem()
+			if d.readElemTo(e, kind) {
+				out.SetMapIndex(reflect.ValueOf(name), e)
+			}
+		case reflect.Struct:
+			if outt == typeRaw {
+				d.readElemTo(blackHole, kind)
+			} else {
+				if info, ok := fieldsMap[name]; ok {
+					d.readElemTo(out.Field(info.Num), kind)
+				} else {
+					d.dropElem(kind)
+				}
+			}
+		}
+
+		if d.i >= end {
+			corrupted()
+		}
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+
+	switch outk {
+	case reflect.Struct:
+		if outt == typeRaw {
+			out.Set(reflect.ValueOf(Raw{0x03, d.in[start:d.i]}))
+		}
+	}
+}
+
+func (d *decoder) readArrayDoc(t reflect.Type) interface{} {
+	tmp := make([]reflect.Value, 0, 8)
+	elemType := t.Elem()
+
+	end := d.i - 4 + int(d.readInt32())
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	for d.in[d.i] != '\x00' {
+		kind := d.readByte()
+		for d.i < end && d.in[d.i] != '\x00' {
+			d.i++
+		}
+		if d.i >= end {
+			corrupted()
+		}
+		d.i++
+		e := reflect.New(elemType).Elem()
+		if d.readElemTo(e, kind) {
+			tmp = append(tmp, e)
+		}
+		if d.i >= end {
+			corrupted()
+		}
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+
+	n := len(tmp)
+	slice := reflect.MakeSlice(t, n, n)
+	for i := 0; i != n; i++ {
+		slice.Index(i).Set(tmp[i])
+	}
+	return slice.Interface()
+}
+
+var typeD = reflect.TypeOf(D{})
+var typeSlice = reflect.TypeOf([]interface{}{})
+
+func (d *decoder) readDocD() interface{} {
+	slice := make(D, 0, 8)
+	d.readDocWith(func(kind byte, name string) {
+		e := DocElem{Name: name}
+		v := reflect.ValueOf(&e.Value)
+		if d.readElemTo(v.Elem(), kind) {
+			slice = append(slice, e)
+		}
+	})
+	return slice
+}
+
+func (d *decoder) readDocWith(f func(kind byte, name string)) {
+	end := d.i - 4 + int(d.readInt32())
+	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
+		corrupted()
+	}
+	for d.in[d.i] != '\x00' {
+		kind := d.readByte()
+		name := d.readCStr()
+		if d.i >= end {
+			corrupted()
+		}
+		f(kind, name)
+		if d.i >= end {
+			corrupted()
+		}
+	}
+	d.i++ // '\x00'
+	if d.i != end {
+		corrupted()
+	}
+}
+
+// --------------------------------------------------------------------------
+// Unmarshaling of individual elements within a document.
+
+var blackHole = settableValueOf(struct{}{})
+
+func (d *decoder) dropElem(kind byte) {
+	d.readElemTo(blackHole, kind)
+}
+
+// Attempt to decode an element from the document and put it into out.
+// If the types are not compatible, the returned ok value will be
+// false and out will be unchanged.
+func (d *decoder) readElemTo(out reflect.Value, kind byte) (good bool) {
+
+	start := d.i
+
+	if kind == '\x03' {
+		// Special case for documents. Delegate to readDocTo().
+		switch out.Kind() {
+		case reflect.Interface, reflect.Ptr, reflect.Struct, reflect.Map:
+			d.readDocTo(out)
+		default:
+			if _, ok := out.Interface().(D); ok {
+				out.Set(reflect.ValueOf(d.readDocD()))
+			} else {
+				d.readDocTo(blackHole)
+			}
+		}
+		return true
+	}
+
+	var in interface{}
+
+	switch kind {
+	case '\x01': // Float64
+		in = d.readFloat64()
+	case '\x02': // UTF-8 string
+		in = d.readStr()
+	case '\x03': // Document
+		panic("Can't happen. Handled above.")
+	case '\x04': // Array
+		outt := out.Type()
+		for outt.Kind() == reflect.Ptr {
+			outt = outt.Elem()
+		}
+		switch outt.Kind() {
+		case reflect.Slice:
+			in = d.readArrayDoc(outt)
+		default:
+			in = d.readArrayDoc(typeSlice)
+		}
+	case '\x05': // Binary
+		b := d.readBinary()
+		if b.Kind == 0x00 {
+			in = b.Data
+		} else {
+			in = b
+		}
+	case '\x06': // Undefined (obsolete, but still seen in the wild)
+		in = Undefined
+	case '\x07': // ObjectId
+		in = ObjectId(d.readBytes(12))
+	case '\x08': // Bool
+		in = d.readBool()
+	case '\x09': // Timestamp
+		// MongoDB wants timestamps as milliseconds.
+		// Go likes nanoseconds.  Convert them.
+		in = Timestamp(d.readInt64() * 1e6)
+	case '\x0A': // Nil
+		in = nil
+	case '\x0B': // RegEx
+		in = d.readRegEx()
+	case '\x0D': // JavaScript without scope
+		in = JS{Code: d.readStr()}
+	case '\x0E': // Symbol
+		in = Symbol(d.readStr())
+	case '\x0F': // JavaScript with scope
+		d.i += 4 // Skip length
+		js := JS{d.readStr(), make(M)}
+		d.readDocTo(reflect.ValueOf(js.Scope))
+		in = js
+	case '\x10': // Int32
+		in = int(d.readInt32())
+	case '\x11': // Mongo-specific timestamp
+		in = MongoTimestamp(d.readInt64())
+	case '\x12': // Int64
+		in = d.readInt64()
+	case '\x7F': // Max key
+		in = MaxKey
+	case '\xFF': // Min key
+		in = MinKey
+	default:
+		panic(fmt.Sprintf("Unknown element kind (0x%02X)", kind))
+	}
+
+	outt := out.Type()
+
+	if outt == typeRaw {
+		out.Set(reflect.ValueOf(Raw{kind, d.in[start:d.i]}))
+		return true
+	}
+
+	if setter, ok := out.Interface().(Setter); ok {
+		if zeroNilPtr(out) {
+			setter = out.Interface().(Setter)
+		}
+		return setter.SetBSON(in)
+	}
+
+	if in == nil {
+		out.Set(reflect.Zero(outt))
+		return true
+	}
+
+	outk := outt.Kind()
+
+	// Dereference and initialize pointer if necessary.
+	first := true
+	for outk == reflect.Ptr {
+		if !out.IsNil() {
+			out = out.Elem()
+		} else {
+			elem := reflect.New(outt.Elem())
+			if first {
+				// Only set if value is compatible.
+				first = false
+				defer func(out, elem reflect.Value) {
+					if good {
+						out.Set(elem)
+					}
+				}(out, elem)
+			} else {
+				out.Set(elem)
+			}
+			out = elem
+		}
+		outt = out.Type()
+		outk = outt.Kind()
+	}
+
+	inv := reflect.ValueOf(in)
+	if outt == inv.Type() {
+		out.Set(inv)
+		return true
+	}
+
+	switch outk {
+	case reflect.Interface:
+		out.Set(inv)
+		return true
+	case reflect.String:
+		switch inv.Kind() {
+		case reflect.String:
+			out.SetString(inv.String())
+			return true
+		case reflect.Slice:
+			if b, ok := in.([]byte); ok {
+				out.SetString(string(b))
+				return true
+			}
+		}
+	case reflect.Slice, reflect.Array:
+		// Remember, array (0x04) slices are built with the correct element
+		// type.  If we are here, must be a cross BSON kind conversion.
+		if outt.Elem().Kind() == reflect.Uint8 {
+			switch inv.Kind() {
+			case reflect.String:
+				slice := []byte(inv.String())
+				out.Set(reflect.ValueOf(slice))
+				return true
+			case reflect.Slice:
+				// out must be an array. A slice would trigger
+				// inv.Type() == out.Type() above.
+				reflect.Copy(out, inv)
+				return true
+			}
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		switch inv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			// MongoDB wants timestamps as milliseconds.
+			// Go likes nanoseconds.  Convert them.
+			// out.Type() == inv.Type() has been handled above.
+			if outt == typeTimestamp {
+				out.SetInt(inv.Int() * 1e6)
+			} else if inv.Type() == typeTimestamp {
+				out.SetInt(inv.Int() / 1e6)
+			} else {
+				out.SetInt(inv.Int())
+			}
+			return true
+		case reflect.Float32, reflect.Float64:
+			out.SetInt(int64(inv.Float()))
+			return true
+		case reflect.Bool:
+			if inv.Bool() {
+				out.SetInt(1)
+			} else {
+				out.SetInt(0)
+			}
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON?")
+		}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		switch inv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetUint(uint64(inv.Int()))
+			return true
+		case reflect.Float32, reflect.Float64:
+			out.SetUint(uint64(inv.Float()))
+			return true
+		case reflect.Bool:
+			if inv.Bool() {
+				out.SetUint(1)
+			} else {
+				out.SetUint(0)
+			}
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON?")
+		}
+	case reflect.Float32, reflect.Float64:
+		switch inv.Kind() {
+		case reflect.Float32, reflect.Float64:
+			out.SetFloat(inv.Float())
+			return true
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetFloat(float64(inv.Int()))
+			return true
+		case reflect.Bool:
+			if inv.Bool() {
+				out.SetFloat(1)
+			} else {
+				out.SetFloat(0)
+			}
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON?")
+		}
+	case reflect.Bool:
+		switch inv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			out.SetBool(inv.Int() != 0)
+			return true
+		case reflect.Float32, reflect.Float64:
+			out.SetBool(inv.Float() != 0)
+			return true
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			panic("Can't happen. No uint types in BSON?")
+		}
+	}
+
+	return false
+}
+
+// --------------------------------------------------------------------------
+// Parsers of basic types.
+
+func (d *decoder) readRegEx() RegEx {
+	re := RegEx{}
+	re.Pattern = d.readCStr()
+	re.Options = d.readCStr()
+	return re
+}
+
+func (d *decoder) readBinary() Binary {
+	l := d.readInt32()
+	b := Binary{}
+	b.Kind = d.readByte()
+	b.Data = d.readBytes(l)
+	if b.Kind == 0x02 {
+		// Weird obsolete format with redundant length.
+		b.Data = b.Data[4:]
+	}
+	return b
+}
+
+func (d *decoder) readStr() string {
+	l := d.readInt32()
+	b := d.readBytes(l - 1)
+	if d.readByte() != '\x00' {
+		corrupted()
+	}
+	return string(b)
+}
+
+func (d *decoder) readCStr() string {
+	start := d.i
+	end := start
+	l := len(d.in)
+	for ; end != l; end++ {
+		if d.in[end] == '\x00' {
+			break
+		}
+	}
+	d.i = end + 1
+	if d.i > l {
+		corrupted()
+	}
+	return string(d.in[start:end])
+}
+
+func (d *decoder) readBool() bool {
+	if d.readByte() == 1 {
+		return true
+	}
+	return false
+}
+
+func (d *decoder) readFloat64() float64 {
+	return math.Float64frombits(uint64(d.readInt64()))
+}
+
+func (d *decoder) readInt32() int32 {
+	b := d.readBytes(4)
+	return int32((uint32(b[0]) << 0) |
+		(uint32(b[1]) << 8) |
+		(uint32(b[2]) << 16) |
+		(uint32(b[3]) << 24))
+}
+
+func (d *decoder) readInt64() int64 {
+	b := d.readBytes(8)
+	return int64((uint64(b[0]) << 0) |
+		(uint64(b[1]) << 8) |
+		(uint64(b[2]) << 16) |
+		(uint64(b[3]) << 24) |
+		(uint64(b[4]) << 32) |
+		(uint64(b[5]) << 40) |
+		(uint64(b[6]) << 48) |
+		(uint64(b[7]) << 56))
+}
+
+func (d *decoder) readByte() byte {
+	i := d.i
+	d.i++
+	if d.i > len(d.in) {
+		corrupted()
+	}
+	return d.in[i]
+}
+
+func (d *decoder) readBytes(length int32) []byte {
+	start := d.i
+	d.i += int(length)
+	if d.i > len(d.in) {
+		corrupted()
+	}
+	return d.in[start : start+int(length)]
+}
 
=== added file 'encode.go'
--- encode.go	1970-01-01 00:00:00 +0000
+++ encode.go	2011-07-28 17:08:30 +0000
@@ -0,0 +1,420 @@
+// gobson - BSON library for Go.
+// 
+// Copyright (c) 2010-2011 - Gustavo Niemeyer <[e-mail]>
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//       this list of conditions and the following disclaimer in the documentation
+//       and/or other materials provided with the distribution.
+//     * Neither the name of the copyright holder nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package bson
+
+import (
+	"strconv"
+	"reflect"
+	"math"
+)
+
+// --------------------------------------------------------------------------
+// Some internal infrastructure.
+
+var (
+	typeRegEx          reflect.Type
+	typeBinary         reflect.Type
+	typeObjectId       reflect.Type
+	typeSymbol         reflect.Type
+	typeTimestamp      reflect.Type
+	typeMongoTimestamp reflect.Type
+	typeOrderKey       reflect.Type
+	typeDocElem        reflect.Type
+	typeRaw            reflect.Type
+)
+
+const itoaCacheSize = 32
+
+var itoaCache []string
+
+func init() {
+	typeBinary = reflect.TypeOf(Binary{})
+	typeObjectId = reflect.TypeOf(ObjectId(""))
+	typeSymbol = reflect.TypeOf(Symbol(""))
+	typeTimestamp = reflect.TypeOf(Timestamp(0))
+	typeMongoTimestamp = reflect.TypeOf(MongoTimestamp(0))
+	typeOrderKey = reflect.TypeOf(MinKey)
+	typeDocElem = reflect.TypeOf(DocElem{})
+	typeRaw = reflect.TypeOf(Raw{})
+
+	itoaCache = make([]string, itoaCacheSize)
+	for i := 0; i != itoaCacheSize; i++ {
+		itoaCache[i] = strconv.Itoa(i)
+	}
+}
+
+func itoa(i int) string {
+	if i < itoaCacheSize {
+		return itoaCache[i]
+	}
+	return strconv.Itoa(i)
+}
+
+
+// --------------------------------------------------------------------------
+// Marshaling of the document value itself.
+
+type encoder struct {
+	out []byte
+}
+
+func (e *encoder) addDoc(v reflect.Value) {
+	for {
+		if vi, ok := v.Interface().(Getter); ok {
+			v = reflect.ValueOf(vi.GetBSON())
+			continue
+		}
+		if v.Kind() == reflect.Ptr {
+			v = v.Elem()
+			continue
+		}
+		break
+	}
+
+	if v.Type() == typeRaw {
+		raw := v.Interface().(Raw)
+		if raw.Kind != 0x03 && raw.Kind != 0x00 {
+			panic("Attempted to unmarshal Raw kind " + strconv.Itoa(int(raw.Kind)) + " as a document")
+		}
+		e.addBytes(raw.Data...)
+		return
+	}
+
+	start := e.reserveInt32()
+
+	switch v.Kind() {
+	case reflect.Map:
+		e.addMap(v)
+	case reflect.Struct:
+		e.addStruct(v)
+	case reflect.Array, reflect.Slice:
+		e.addSlice(v)
+	default:
+		panic("Can't marshal " + v.Type().String() + " as a BSON document")
+	}
+
+	e.addBytes(0)
+	e.setInt32(start, int32(len(e.out)-start))
+}
+
+func (e *encoder) addMap(v reflect.Value) {
+	for _, k := range v.MapKeys() {
+		e.addElem(k.String(), v.MapIndex(k), false)
+	}
+}
+
+func (e *encoder) addStruct(v reflect.Value) {
+	fields, err := getStructFields(v.Type())
+	if err != nil {
+		panic(err)
+	}
+	for i, info := range fields.List {
+		value := v.Field(i)
+		if info.Conditional && isZero(value) {
+			continue
+		}
+		e.addElem(info.Key, value, info.Short)
+	}
+}
+
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.String:
+		return len(v.String()) == 0
+	case reflect.Ptr, reflect.Interface:
+		return v.IsNil()
+	case reflect.Slice:
+		return v.Len() == 0
+	case reflect.Map:
+		return v.Len() == 0
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	}
+	return false
+}
+
+func (e *encoder) addSlice(v reflect.Value) {
+	if d, ok := v.Interface().(D); ok {
+		for _, elem := range d {
+			e.addElem(elem.Name, reflect.ValueOf(elem.Value), false)
+		}
+	} else {
+		for i := 0; i != v.Len(); i++ {
+			e.addElem(itoa(i), v.Index(i), false)
+		}
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Marshaling of elements in a document.
+
+func (e *encoder) addElemName(kind byte, name string) {
+	e.addBytes(kind)
+	e.addBytes([]byte(name)...)
+	e.addBytes(0)
+}
+
+func (e *encoder) addElem(name string, v reflect.Value, short bool) {
+
+	if !v.IsValid() {
+		e.addElemName('\x0A', name)
+		return
+	}
+
+	if getter, ok := v.Interface().(Getter); ok {
+		e.addElem(name, reflect.ValueOf(getter.GetBSON()), short)
+		return
+	}
+
+	switch v.Kind() {
+
+	case reflect.Interface:
+		e.addElem(name, v.Elem(), short)
+
+	case reflect.Ptr:
+		e.addElem(name, v.Elem(), short)
+
+	case reflect.String:
+		s := v.String()
+
+		switch v.Type() {
+
+		case typeObjectId:
+			if len(s) != 12 {
+				panic("ObjectIDs must be exactly 12 bytes long (got " +
+					strconv.Itoa(len(s)) + ")")
+			}
+			e.addElemName('\x07', name)
+			e.addBytes([]byte(s)...)
+
+		case typeSymbol:
+			e.addElemName('\x0E', name)
+			e.addStr(s)
+
+		default:
+			e.addElemName('\x02', name)
+			e.addStr(s)
+		}
+
+	case reflect.Float32, reflect.Float64:
+		e.addElemName('\x01', name)
+		e.addInt64(int64(math.Float64bits(v.Float())))
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		u := v.Uint()
+		if int64(u) < 0 {
+			panic("BSON has no uint64 type, and value is too large to fit correctly in an int64")
+		} else if u <= math.MaxInt32 && (short || v.Kind() <= reflect.Uint32) {
+			e.addElemName('\x10', name)
+			e.addInt32(int32(u))
+		} else {
+			e.addElemName('\x12', name)
+			e.addInt64(int64(u))
+		}
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if v.Type().Kind() <= reflect.Int32 {
+			e.addElemName('\x10', name)
+			e.addInt32(int32(v.Int()))
+		} else {
+			switch v.Type() {
+
+			case typeTimestamp:
+				// MongoDB wants timestamps as milliseconds.
+				// Go likes nanoseconds.  Convert them.
+				e.addElemName('\x09', name)
+				e.addInt64(v.Int() / 1e6)
+
+			case typeMongoTimestamp:
+				e.addElemName('\x11', name)
+				e.addInt64(v.Int())
+
+			case typeOrderKey:
+				if v.Int() == int64(MaxKey) {
+					e.addElemName('\x7F', name)
+				} else {
+					e.addElemName('\xFF', name)
+				}
+
+			default:
+				i := v.Int()
+				if short && i >= math.MinInt32 && i <= math.MaxInt32 {
+					// It fits into an int32, encode as such.
+					e.addElemName('\x10', name)
+					e.addInt32(int32(i))
+				} else {
+					e.addElemName('\x12', name)
+					e.addInt64(i)
+				}
+			}
+		}
+
+	case reflect.Bool:
+		e.addElemName('\x08', name)
+		if v.Bool() {
+			e.addBytes(1)
+		} else {
+			e.addBytes(0)
+		}
+
+	case reflect.Map:
+		e.addElemName('\x03', name)
+		e.addDoc(v)
+
+	case reflect.Slice:
+		vt := v.Type()
+		et := vt.Elem()
+		if et.Kind() == reflect.Uint8 {
+			// FIXME: This breaks down with custom types based on []byte
+			e.addElemName('\x05', name)
+			e.addBinary('\x00', v.Interface().([]byte))
+		} else if et == typeDocElem {
+			e.addElemName('\x03', name)
+			e.addDoc(v)
+		} else {
+			e.addElemName('\x04', name)
+			e.addDoc(v)
+		}
+
+	case reflect.Array:
+		et := v.Type().Elem()
+		if et.Kind() == reflect.Uint8 {
+			e.addElemName('\x05', name)
+			e.addBinary('\x00', v.Slice(0, v.Len()).Interface().([]byte))
+		} else {
+			e.addElemName('\x04', name)
+			e.addDoc(v)
+		}
+
+	case reflect.Struct:
+		switch s := v.Interface().(type) {
+
+		case Raw:
+			kind := s.Kind
+			if kind == 0x00 {
+				kind = 0x03
+			}
+			e.addElemName(kind, name)
+			e.addBytes(s.Data...)
+
+		case Binary:
+			e.addElemName('\x05', name)
+			e.addBinary(s.Kind, s.Data)
+
+		case RegEx:
+			e.addElemName('\x0B', name)
+			e.addCStr(s.Pattern)
+			e.addCStr(s.Options)
+
+		case JS:
+			if s.Scope == nil {
+				e.addElemName('\x0D', name)
+				e.addStr(s.Code)
+			} else {
+				e.addElemName('\x0F', name)
+				start := e.reserveInt32()
+				e.addStr(s.Code)
+				e.addDoc(reflect.ValueOf(s.Scope))
+				e.setInt32(start, int32(len(e.out)-start))
+			}
+
+		case undefined:
+			e.addElemName('\x06', name)
+
+		default:
+			e.addElemName('\x03', name)
+			e.addDoc(v)
+		}
+
+	default:
+		panic("Can't marshal " + v.Type().String() + " in a BSON document")
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Marshaling of base types.
+
+func (e *encoder) addBinary(subtype byte, v []byte) {
+	if subtype == 0x02 {
+		// Wonder how that brilliant idea came to life. Obsolete, luckily.
+		e.addInt32(int32(len(v) + 4))
+		e.addBytes(subtype)
+		e.addInt32(int32(len(v)))
+	} else {
+		e.addInt32(int32(len(v)))
+		e.addBytes(subtype)
+	}
+	e.addBytes(v...)
+}
+
+func (e *encoder) addStr(v string) {
+	e.addInt32(int32(len(v) + 1))
+	e.addCStr(v)
+}
+
+func (e *encoder) addCStr(v string) {
+	e.addBytes([]byte(v)...)
+	e.addBytes(0)
+}
+
+func (e *encoder) reserveInt32() (pos int) {
+	pos = len(e.out)
+	e.addBytes(0, 0, 0, 0)
+	return pos
+}
+
+func (e *encoder) setInt32(pos int, v int32) {
+	e.out[pos+0] = byte(v)
+	e.out[pos+1] = byte(v >> 8)
+	e.out[pos+2] = byte(v >> 16)
+	e.out[pos+3] = byte(v >> 24)
+}
+
+func (e *encoder) addInt32(v int32) {
+	u := uint32(v)
+	e.addBytes(byte(u), byte(u>>8), byte(u>>16), byte(u>>24))
+}
+
+func (e *encoder) addInt64(v int64) {
+	u := uint64(v)
+	e.addBytes(byte(u), byte(u>>8), byte(u>>16), byte(u>>24),
+		byte(u>>32), byte(u>>40), byte(u>>48), byte(u>>56))
+}
+
+func (e *encoder) addBytes(v ...byte) {
+	e.out = append(e.out, v...)
+}
 
=== added file 'gobson.go'
--- gobson.go	1970-01-01 00:00:00 +0000
+++ gobson.go	2011-07-28 17:08:30 +0000
@@ -0,0 +1,483 @@
+// gobson - BSON library for Go.
+// 
+// Copyright (c) 2010-2011 - Gustavo Niemeyer <[e-mail]>
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//       this list of conditions and the following disclaimer in the documentation
+//       and/or other materials provided with the distribution.
+//     * Neither the name of the copyright holder nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package bson
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"crypto/md5"
+	"runtime"
+	"reflect"
+	"strings"
+	"sync/atomic"
+	"sync"
+	"time"
+	"fmt"
+	"os"
+)
+
+// --------------------------------------------------------------------------
+// The public API.
+
+// Objects implementing the bson.Getter interface will get the GetBSON()
+// method called when the given value has to be marshalled, and the result
+// of this method will be marshaled in place of the actual object.
+type Getter interface {
+	GetBSON() interface{}
+}
+
+// Objects implementing the bson.Setter interface will receive the BSON
+// value via the SetBSON method during unmarshaling, and will not be
+// changed as usual.  If setting the value works, the method should
+// return true.  If it returns false, the given value will be omitted
+// from maps and slices.
+type Setter interface {
+	SetBSON(v interface{}) (ok bool)
+}
+
+// Handy alias for a map[string]interface{} map, useful for dealing with BSON
+// in a native way.  For instance:
+//
+//     bson.M{"a": 1, "b": true}
+//
+// There's no special handling for this type in addition to what's done anyway
+// for an equivalent map type.  Elements in the map will be dumped in an
+// undefined ordered. See also the bson.D type for an ordered alternative.
+type M map[string]interface{}
+
+// Type for dealing with documents containing ordered elements in a native
+// fashion. For instance:
+//
+//     bson.D{{"a", 1}, {"b", true}}
+//
+// In some situations, such as when creating indexes for MongoDB, the order in
+// which the elements are defined is important.  If the order is not important,
+// using a map is generally more comfortable (see the bson.M type and the
+// Map() method for D).
+type D []DocElem
+
+// See the bson.D type.
+type DocElem struct {
+	Name  string
+	Value interface{}
+}
+
+// Raw may be used to work with raw unprocessed BSON documents and elements,
+// if necessary in advanced cases.  Kind is the kind of element as defined
+// per the BSON specification, and Data is the raw unprocessed data for
+// the respective element.
+//
+// Relevant documentation:
+//
+//     http://bsonspec.org/#/specification
+//
+type Raw struct {
+	Kind byte
+	Data []byte
+}
+
+// Build a map[string]interface{} out of the ordered element name/value pairs.
+func (d D) Map() (m M) {
+	m = make(M, len(d))
+	for _, item := range d {
+		m[item.Name] = item.Value
+	}
+	return m
+}
+
+// Unique ID identifying the BSON object. Must be exactly 12 bytes long.
+// MongoDB objects by default have such a property set in their "_id"
+// property.
+//
+// http://www.mongodb.org/display/DOCS/Object+IDs
+type ObjectId string
+
+// ObjectIdHex returns an ObjectId from the provided hex representation.
+// Calling this function with an invalid hex representation will
+// cause a runtime panic.
+func ObjectIdHex(s string) ObjectId {
+	d, err := hex.DecodeString(s)
+	if err != nil || len(d) != 12 {
+		panic(fmt.Sprintf("Invalid input to ObjectIdHex: %q", s))
+	}
+	return ObjectId(d)
+}
+
+// objectIdCounter is atomically incremented when generating a new ObjectId
+// using NewObjectId() function. It's used as a counter part of an id.
+var objectIdCounter uint32 = 0
+
+// machineId stores machine id generated once and used in subsequent calls
+// to NewObjectId function.
+var machineId []byte
+
+// initMachineId generates machine id and puts it into the machineId global
+// variable. If this function fails to get the hostname, it will cause
+// a runtime error.
+func initMachineId() {
+	var sum [3]byte
+	hostname, err := os.Hostname()
+	if err != nil {
+		panic("Failed to get hostname: " + err.String())
+	}
+	hw := md5.New()
+	hw.Write([]byte(hostname))
+	copy(sum[:3], hw.Sum())
+	machineId = sum[:]
+}
+
+// NewObjectId generates and returns a new unique ObjectId.
+// This function causes a runtime error if it fails to get the hostname
+// of the current machine.
+func NewObjectId() ObjectId {
+	b := make([]byte, 12)
+	// Timestamp, 4 bytes, big endian
+	binary.BigEndian.PutUint32(b, uint32(time.Seconds()))
+	// Machine, first 3 bytes of md5(hostname)
+	if machineId == nil {
+		initMachineId()
+	}
+	b[4] = machineId[0]
+	b[5] = machineId[1]
+	b[6] = machineId[2]
+	// Pid, 2 bytes, specs don't specify endianness, but we use big endian.
+	pid := os.Getpid()
+	b[7] = byte(pid >> 8)
+	b[8] = byte(pid)
+	// Increment, 3 bytes, big endian
+	i := atomic.AddUint32(&objectIdCounter, 1)
+	b[9] = byte(i >> 16)
+	b[10] = byte(i >> 8)
+	b[11] = byte(i)
+	return ObjectId(b)
+}
+
+// NewObjectIdSeconds returns a dummy ObjectId with the timestamp part filled
+// with the provided number of seconds from epoch UTC, and all other parts
+// filled with zeroes. It's not safe to insert a document with an id generated
+// by this method, it is useful only for queries to find documents with ids
+// generated before or after the specified timestamp.
+func NewObjectIdSeconds(sec int32) ObjectId {
+	var b [12]byte
+	binary.BigEndian.PutUint32(b[:4], uint32(sec))
+	return ObjectId(string(b[:]))
+}
+
+// String returns a hex string representation of the id.
+// Example: ObjectIdHex("4d88e15b60f486e428412dc9").
+func (id ObjectId) String() string {
+	return `ObjectIdHex("` + hex.EncodeToString([]byte(string(id))) + `")`
+}
+
+// Valid returns true if the id is valid (contains exactly 12 bytes)
+func (id ObjectId) Valid() bool {
+	return len(id) == 12
+}
+
+// byteSlice returns byte slice of id from start to end.
+// Calling this function with an invalid id will cause a runtime panic.
+func (id ObjectId) byteSlice(start, end int) []byte {
+	if len(id) != 12 {
+		panic(fmt.Sprintf("Invalid ObjectId: %q", string(id)))
+	}
+	return []byte(string(id)[start:end])
+}
+
+// Timestamp returns the timestamp part of the id (the number of seconds
+// from epoch in UTC). 
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Timestamp() int32 {
+	// First 4 bytes of ObjectId is 32-bit big-endian timestamp
+	return int32(binary.BigEndian.Uint32(id.byteSlice(0, 4)))
+}
+
+// Machine returns the 3-byte machine id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Machine() []byte {
+	return id.byteSlice(4, 7)
+}
+
+// Pid returns the process id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Pid() uint16 {
+	return binary.BigEndian.Uint16(id.byteSlice(7, 9))
+}
+
+// Counter returns the incrementing value part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ObjectId) Counter() int32 {
+	b := id.byteSlice(9, 12)
+	// Counter is stored as big-endian 3-byte value
+	return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+}
+
+// Similar to a string, but used in languages with a distinct symbol type. This
+// is an alias to a string type, so it can be used in string contexts and
+// string(symbol) will work correctly.
+type Symbol string
+
+// UTC timestamp defined as nanoseconds since the traditional epoch time.  The
+// internal MongoDB representation stores this value as milliseconds, so some
+// precision will be lost when sending a Go value to MongoDB, but given that
+// Go most commonly uses nanoseconds in time-related operations, this conversion
+// is convenient.
+type Timestamp int64
+
+// Now returns a Timestamp value with the current time in nanoseconds.
+func Now() Timestamp {
+	// The value is stored in MongoDB as milliseconds, so truncate the value
+	// ahead of time to avoid surprises after a roundtrip.
+	return Timestamp(time.Nanoseconds() / 1e6 * 1e6)
+}
+
+// Special internal type used by MongoDB which for some strange reason has its
+// own datatype defined in BSON.
+type MongoTimestamp int64
+
+type orderKey int64
+
+// Special value which compares higher than all other possible BSON values.
+var MaxKey = orderKey(1<<63 - 1)
+
+// Special value which compares lower than all other possible BSON values.
+var MinKey = orderKey(-1 << 63)
+
+type undefined struct{}
+
+var Undefined undefined
+
+// Representation for non-standard binary values.  Any kind should work,
+// but the following are known as of this writing:
+//
+//   0x00 - Generic. This is decoded as []byte(data), not Binary{0x00, data}.
+//   0x01 - Function (!?)
+//   0x02 - Obsolete generic.
+//   0x03 - UUID
+//   0x05 - MD5
+//   0x80 - User defined.
+//
+type Binary struct {
+	Kind byte
+	Data []byte
+}
+
+// A special type for regular expressions.  The Options field should contain
+// individual characters defining the way in which the pattern should be
+// applied, and must be sorted. Valid options as of this writing are 'i' for
+// case insensitive matching, 'm' for multi-line matching, 'x' for verbose
+// mode, 'l' to make \w, \W, and similar be locale-dependent, 's' for dot-all
+// mode (a '.' matches everything), and 'u' to make \w, \W, and similar match
+// unicode. The value of the Options parameter is not verified before being
+// marshaled into the BSON format.
+type RegEx struct {
+	Pattern string
+	Options string
+}
+
+// Special type for JavaScript code.  If Scope is non-nil, it will be marshaled
+// as a mapping from identifiers to values which should be used when evaluating
+// the provided Code.
+type JS struct {
+	Code  string
+	Scope interface{}
+}
+
+
+const initialBufferSize = 64
+
+func handleErr(err *os.Error) {
+	if r := recover(); r != nil {
+		if _, ok := r.(runtime.Error); ok {
+			panic(r)
+		} else if s, ok := r.(string); ok {
+			*err = os.NewError(s)
+		} else if e, ok := r.(os.Error); ok {
+			*err = e
+		} else {
+			panic(r)
+		}
+	}
+}
+
+
+// Marshal serializes the in document, which may be a map or a struct value.
+// In the case of struct values, only exported fields will be serialized.
+// These fields may optionally have tags to define the serialization key for
+// the respective fields.  Without a tag, the lowercased field name is used
+// as the key for each field.  If a field tag ends in "/c", that field will
+// only be serialized if it's not set to the zero value for the field type.
+// If a field tag ends with the "/s" suffix, an int64 value in the given
+// field will be serialized as an int32 if possible.
+func Marshal(in interface{}) (out []byte, err os.Error) {
+	defer handleErr(&err)
+	e := &encoder{make([]byte, 0, initialBufferSize)}
+	e.addDoc(reflect.ValueOf(in))
+	return e.out, nil
+}
+
+// Unmarshal deserializes data from in into the out value.  The out value
+// must be a map or a pointer to a struct (or a pointer to a struct pointer).
+// In the case of struct values, field names are mapped to the struct using
+// the field tag as the key.  If the field has no tag, its lowercased name
+// will be used as the default key.  Nil values are properly initialized
+// when necessary.
+//
+// The target field types of out may not necessarily match the BSON values
+// of the provided data.  If there is a sensible way to unmarshal the values
+// into the Go types, they will be converted.  Otherwise, the incompatible
+// values will be silently skipped.
+func Unmarshal(in []byte, out interface{}) (err os.Error) {
+	defer handleErr(&err)
+	v := reflect.ValueOf(out)
+	switch v.Kind() {
+	case reflect.Map, reflect.Ptr:
+		d := &decoder{in: in}
+		d.readDocTo(v)
+	case reflect.Struct:
+		return os.NewError("Unmarshal can't deal with struct values. Use a pointer.")
+	default:
+		return os.NewError("Unmarshal needs a map or a pointer to a struct.")
+	}
+	return nil
+}
+
+// Unmarshal deserializes raw into the out value.  In addition to whole
+// documents, Raw's Unmarshal may also be used to unmarshal the data for
+// individual elements within a partially unmarshalled document.  This
+// enables parts of a document to be lazily and conditionally deserialized.
+// 
+// If the out value type is not compatible with raw, a *bson.TypeError
+// is returned.
+func (raw Raw) Unmarshal(out interface{}) (err os.Error) {
+	defer handleErr(&err)
+	v := reflect.ValueOf(out)
+	switch v.Kind() {
+	case reflect.Map, reflect.Ptr:
+		d := &decoder{in: raw.Data}
+		good := d.readElemTo(v, raw.Kind)
+		if !good {
+			return &TypeError{v.Type(), raw.Kind}
+		}
+	default:
+		return os.NewError("Raw Unmarshal needs a map or a valid pointer.")
+	}
+	return nil
+}
+
+type TypeError struct {
+	Type reflect.Type
+	Kind byte
+}
+
+func (e *TypeError) String() string {
+	return fmt.Sprintf("BSON kind 0x%02x isn't compatible with type %s", e.Kind, e.Type.String())
+}
+
+// --------------------------------------------------------------------------
+// Maintain a mapping of keys to structure field indexes
+
+type structFields struct {
+	Map  map[string]fieldInfo
+	List []fieldInfo
+}
+
+type fieldInfo struct {
+	Key         string
+	Num         int
+	Conditional bool
+	Short       bool
+}
+
+var fieldMap = make(map[string]*structFields)
+var fieldMapMutex sync.RWMutex
+
+func getStructFields(st reflect.Type) (*structFields, os.Error) {
+	path := st.PkgPath()
+	name := st.Name()
+
+	fullName := path + "." + name
+	fieldMapMutex.RLock()
+	fields, found := fieldMap[fullName]
+	fieldMapMutex.RUnlock()
+	if found {
+		return fields, nil
+	}
+
+	n := st.NumField()
+	fieldsMap := make(map[string]fieldInfo)
+	fieldsList := make([]fieldInfo, n)
+	for i := 0; i != n; i++ {
+		field := st.Field(i)
+		if field.PkgPath != "" {
+			continue // Private field
+		}
+
+		info := fieldInfo{Num: i}
+
+		if s := strings.LastIndex(string(field.Tag), "/"); s != -1 {
+			for _, c := range field.Tag[s+1:] {
+				switch c {
+				case int('c'):
+					info.Conditional = true
+				case int('s'):
+					info.Short = true
+				default:
+					panic("Unsupported field flag: " + string([]int{c}))
+				}
+			}
+			field.Tag = field.Tag[:s]
+		}
+
+		if field.Tag != "" {
+			info.Key = string(field.Tag)
+		} else {
+			info.Key = strings.ToLower(field.Name)
+		}
+
+		if _, found = fieldsMap[info.Key]; found {
+			msg := "Duplicated key '" + info.Key + "' in struct " + st.String()
+			return nil, os.NewError(msg)
+		}
+
+		fieldsList[len(fieldsMap)] = info
+		fieldsMap[info.Key] = info
+	}
+
+	fields = &structFields{fieldsMap, fieldsList[:len(fieldsMap)]}
+
+	if fullName != "." {
+		fieldMapMutex.Lock()
+		fieldMap[fullName] = fields
+		fieldMapMutex.Unlock()
+	}
+
+	return fields, nil
+}
 
=== added file 'gobson_test.go'
--- gobson_test.go	1970-01-01 00:00:00 +0000
+++ gobson_test.go	2011-07-28 17:08:30 +0000
@@ -0,0 +1,1096 @@
+// gobson - BSON library for Go.
+// 
+// Copyright (c) 2010-2011 - Gustavo Niemeyer <[e-mail]>
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//       this list of conditions and the following disclaimer in the documentation
+//       and/or other materials provided with the distribution.
+//     * Neither the name of the copyright holder nor the names of its
+//       contributors may be used to endorse or promote products derived from
+//       this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package bson_test
+
+import (
+	. "launchpad.net/gocheck"
+	"encoding/binary"
+	"testing"
+	"reflect"
+	"time"
+	"launchpad.net/gobson/bson"
+)
+
+
+func TestAll(t *testing.T) {
+	TestingT(t)
+}
+
+type S struct{}
+
+var _ = Suite(&S{})
+
+
+// Wrap up the document elements contained in data, prepending the int32
+// length of the data, and appending the '\x00' value closing the document.
+func wrapInDoc(data string) string {
+	result := make([]byte, len(data)+5)
+	binary.LittleEndian.PutUint32(result, uint32(len(result)))
+	copy(result[4:], []byte(data))
+	return string(result)
+}
+
+func makeZeroDoc(value interface{}) (zero interface{}) {
+	v := reflect.ValueOf(value)
+	t := v.Type()
+	if t.Kind() == reflect.Map {
+		mv := reflect.MakeMap(t)
+		zero = mv.Interface()
+	} else {
+		pv := reflect.New(v.Type().Elem())
+		zero = pv.Interface()
+	}
+	return zero
+}
+
+func testUnmarshal(c *C, data string, obj interface{}) {
+	zero := makeZeroDoc(obj)
+	err := bson.Unmarshal([]byte(data), zero)
+	c.Assert(err, IsNil)
+	c.Assert(zero, Equals, obj)
+}
+
+
+type testItemType struct {
+	obj  interface{}
+	data string
+}
+
+// --------------------------------------------------------------------------
+// Samples from bsonspec.org:
+
+var sampleItems = []testItemType{
+	{bson.M{"hello": "world"},
+		"\x16\x00\x00\x00\x02hello\x00\x06\x00\x00\x00world\x00\x00"},
+	{bson.M{"BSON": []interface{}{"awesome", float64(5.05), 1986}},
+		"1\x00\x00\x00\x04BSON\x00&\x00\x00\x00\x020\x00\x08\x00\x00\x00" +
+			"awesome\x00\x011\x00333333\x14@\x102\x00\xc2\x07\x00\x00\x00\x00"},
+}
+
+func (s *S) TestMarshalSampleItems(c *C) {
+	for i, item := range sampleItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, item.data,
+			Bug("Failed on item %d", i))
+	}
+}
+
+func (s *S) TestUnmarshalSampleItems(c *C) {
+	for i, item := range sampleItems {
+		value := bson.M{}
+		err := bson.Unmarshal([]byte(item.data), value)
+		c.Assert(err, IsNil)
+		c.Assert(value, Equals, item.obj,
+			Bug("Failed on item %d", i))
+	}
+}
+
+// --------------------------------------------------------------------------
+// Every type, ordered by the type flag. These are not wrapped with the
+// length and last \x00 from the document. wrapInDoc() computes them.
+// Note that all of them should be supported as two-way conversions.
+
+var allItems = []testItemType{
+	{bson.M{},
+		""},
+	{bson.M{"_": float64(5.05)},
+		"\x01_\x00333333\x14@"},
+	{bson.M{"_": "yo"},
+		"\x02_\x00\x03\x00\x00\x00yo\x00"},
+	{bson.M{"_": bson.M{"a": true}},
+		"\x03_\x00\x09\x00\x00\x00\x08a\x00\x01\x00"},
+	{bson.M{"_": []interface{}{true, false}},
+		"\x04_\x00\r\x00\x00\x00\x080\x00\x01\x081\x00\x00\x00"},
+	{bson.M{"_": []byte("yo")},
+		"\x05_\x00\x02\x00\x00\x00\x00yo"},
+	{bson.M{"_": bson.Binary{0x02, []byte("old")}},
+		"\x05_\x00\x07\x00\x00\x00\x02\x03\x00\x00\x00old"},
+	{bson.M{"_": bson.Binary{0x80, []byte("udef")}},
+		"\x05_\x00\x04\x00\x00\x00\x80udef"},
+	{bson.M{"_": bson.Undefined}, // Obsolete, but still seen in the wild.
+		"\x06_\x00"},
+	{bson.M{"_": bson.ObjectId("0123456789ab")},
+		"\x07_\x000123456789ab"},
+	{bson.M{"_": false},
+		"\x08_\x00\x00"},
+	{bson.M{"_": true},
+		"\x08_\x00\x01"},
+	{bson.M{"_": bson.Timestamp(258e6)}, // Note the NS <=> MS conversion.
+		"\x09_\x00\x02\x01\x00\x00\x00\x00\x00\x00"},
+	{bson.M{"_": nil},
+		"\x0A_\x00"},
+	{bson.M{"_": bson.RegEx{"ab", "cd"}},
+		"\x0B_\x00ab\x00cd\x00"},
+	{bson.M{"_": bson.JS{"code", nil}},
+		"\x0D_\x00\x05\x00\x00\x00code\x00"},
+	{bson.M{"_": bson.Symbol("sym")},
+		"\x0E_\x00\x04\x00\x00\x00sym\x00"},
+	{bson.M{"_": bson.JS{"code", bson.M{"": nil}}},
+		"\x0F_\x00\x14\x00\x00\x00\x05\x00\x00\x00code\x00" +
+			"\x07\x00\x00\x00\x0A\x00\x00"},
+	{bson.M{"_": 258},
+		"\x10_\x00\x02\x01\x00\x00"},
+	{bson.M{"_": bson.MongoTimestamp(258)},
+		"\x11_\x00\x02\x01\x00\x00\x00\x00\x00\x00"},
+	{bson.M{"_": int64(258)},
+		"\x12_\x00\x02\x01\x00\x00\x00\x00\x00\x00"},
+	{bson.M{"_": int64(258 << 32)},
+		"\x12_\x00\x00\x00\x00\x00\x02\x01\x00\x00"},
+	{bson.M{"_": bson.MaxKey},
+		"\x7F_\x00"},
+	{bson.M{"_": bson.MinKey},
+		"\xFF_\x00"},
+}
+
+func (s *S) TestMarshalAllItems(c *C) {
+	for i, item := range allItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, wrapInDoc(item.data), Bug("Failed on item %d: %#v", i, item))
+	}
+}
+
+func (s *S) TestUnmarshalAllItems(c *C) {
+	for i, item := range allItems {
+		value := bson.M{}
+		err := bson.Unmarshal([]byte(wrapInDoc(item.data)), value)
+		c.Assert(err, IsNil)
+		c.Assert(value, Equals, item.obj, Bug("Failed on item %d: %#v", i, item))
+	}
+}
+
+func (s *S) TestUnmarshalRawAllItems(c *C) {
+	for i, item := range allItems {
+		if len(item.data) == 0 {
+			continue
+		}
+		value := item.obj.(bson.M)["_"]
+		if value == nil {
+			continue
+		}
+		pv := reflect.New(reflect.ValueOf(value).Type())
+		raw := bson.Raw{item.data[0], []byte(item.data[3:])}
+		c.Logf("Unmarshal raw: %#v, %#v", raw, pv.Interface())
+		err := raw.Unmarshal(pv.Interface())
+		c.Assert(err, IsNil)
+		c.Assert(pv.Elem().Interface(), Equals, value, Bug("Failed on item %d: %#v", i, item))
+	}
+}
+
+func (s *S) TestUnmarshalRawIncompatible(c *C) {
+	raw := bson.Raw{0x08, []byte{0x01}} // true
+	err := raw.Unmarshal(&struct{}{})
+	c.Assert(err, Matches, `BSON kind 0x08 isn't compatible with type \*struct { }`)
+}
+
+// --------------------------------------------------------------------------
+// Some one way marshaling operations which would unmarshal differently.
+
+var oneWayMarshalItems = []testItemType{
+	// These are being passed as pointers, and will unmarshal as values.
+	{bson.M{"": &bson.Binary{0x02, []byte("old")}},
+		"\x05\x00\x07\x00\x00\x00\x02\x03\x00\x00\x00old"},
+	{bson.M{"": &bson.Binary{0x80, []byte("udef")}},
+		"\x05\x00\x04\x00\x00\x00\x80udef"},
+	{bson.M{"": &bson.RegEx{"ab", "cd"}},
+		"\x0B\x00ab\x00cd\x00"},
+	{bson.M{"": &bson.JS{"code", nil}},
+		"\x0D\x00\x05\x00\x00\x00code\x00"},
+	{bson.M{"": &bson.JS{"code", bson.M{"": nil}}},
+		"\x0F\x00\x14\x00\x00\x00\x05\x00\x00\x00code\x00" +
+			"\x07\x00\x00\x00\x0A\x00\x00"},
+
+	// There's no float32 type in BSON.  Will encode as a float64.
+	{bson.M{"": float32(5.05)},
+		"\x01\x00\x00\x00\x00@33\x14@"},
+
+	// The array will be unmarshaled as a slice instead.
+	{bson.M{"": [2]bool{true, false}},
+		"\x04\x00\r\x00\x00\x00\x080\x00\x01\x081\x00\x00\x00"},
+
+	// The typed slice will be unmarshaled as []interface{}.
+	{bson.M{"": []bool{true, false}},
+		"\x04\x00\r\x00\x00\x00\x080\x00\x01\x081\x00\x00\x00"},
+
+	// Will unmarshal as a []byte.
+	{bson.M{"": bson.Binary{0x00, []byte("yo")}},
+		"\x05\x00\x02\x00\x00\x00\x00yo"},
+
+	// No way to preserve the type information here. We might encode as a zero
+	// value, but this would mean that pointer values in structs wouldn't be
+	// able to correctly distinguish between unset and set to the zero value.
+	{bson.M{"": (*byte)(nil)},
+		"\x0A\x00"},
+
+	// No int types smaller than int32 in BSON. Could encode this as a char,
+	// but it would still be ambiguous, take more, and be awkward in Go when
+	// loaded without typing information.
+	{bson.M{"": byte(8)},
+		"\x10\x00\x08\x00\x00\x00"},
+
+	// There are no unsigned types in BSON.  Will unmarshal as int32 or int64.
+	{bson.M{"": uint32(258)},
+		"\x10\x00\x02\x01\x00\x00"},
+	{bson.M{"": uint64(258)},
+		"\x12\x00\x02\x01\x00\x00\x00\x00\x00\x00"},
+	{bson.M{"": uint64(258 << 32)},
+		"\x12\x00\x00\x00\x00\x00\x02\x01\x00\x00"},
+
+	// This will unmarshal as int.
+	{bson.M{"": int32(258)},
+		"\x10\x00\x02\x01\x00\x00"},
+
+	// That's a special case. The unsigned value is too large for an int32,
+	// so an int64 is used instead.
+	{bson.M{"": uint32(1<<32 - 1)},
+		"\x12\x00\xFF\xFF\xFF\xFF\x00\x00\x00\x00"},
+	{bson.M{"": uint(1<<32 - 1)},
+		"\x12\x00\xFF\xFF\xFF\xFF\x00\x00\x00\x00"},
+}
+
+func (s *S) TestOneWayMarshalItems(c *C) {
+	for i, item := range oneWayMarshalItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, wrapInDoc(item.data),
+			Bug("Failed on item %d", i))
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Two-way tests for user-defined structures using the samples
+// from bsonspec.org.
+
+type specSample1 struct {
+	Hello string
+}
+
+type specSample2 struct {
+	BSON []interface{} "BSON"
+}
+
+var structSampleItems = []testItemType{
+	{&specSample1{"world"},
+		"\x16\x00\x00\x00\x02hello\x00\x06\x00\x00\x00world\x00\x00"},
+	{&specSample2{[]interface{}{"awesome", float64(5.05), 1986}},
+		"1\x00\x00\x00\x04BSON\x00&\x00\x00\x00\x020\x00\x08\x00\x00\x00" +
+			"awesome\x00\x011\x00333333\x14@\x102\x00\xc2\x07\x00\x00\x00\x00"},
+}
+
+
+func (s *S) TestMarshalStructSampleItems(c *C) {
+	for i, item := range structSampleItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, item.data,
+			Bug("Failed on item %d", i))
+	}
+}
+
+func (s *S) TestUnmarshalStructSampleItems(c *C) {
+	for _, item := range structSampleItems {
+		testUnmarshal(c, item.data, item.obj)
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Generic two-way struct marshaling tests.
+
+var bytevar = byte(8)
+var byteptr = &bytevar
+
+var structItems = []testItemType{
+	{&struct{ Ptr *byte }{nil},
+		"\x0Aptr\x00"},
+	{&struct{ Ptr *byte }{&bytevar},
+		"\x10ptr\x00\x08\x00\x00\x00"},
+	{&struct{ Ptr **byte }{&byteptr},
+		"\x10ptr\x00\x08\x00\x00\x00"},
+	{&struct{ Byte byte }{8},
+		"\x10byte\x00\x08\x00\x00\x00"},
+	{&struct{ Byte byte }{0},
+		"\x10byte\x00\x00\x00\x00\x00"},
+	{&struct {
+		V byte "Tag"
+	}{8},
+		"\x10Tag\x00\x08\x00\x00\x00"},
+	{&struct {
+		V *struct {
+			Byte byte
+		}
+	}{&struct{ Byte byte }{8}},
+		"\x03v\x00" + "\x0f\x00\x00\x00\x10byte\x00\b\x00\x00\x00\x00"},
+	{&struct{ priv byte }{}, ""},
+
+	// The order of the dumped fields should be the same in the struct.
+	{&struct{ A, C, B, D, F, E *byte }{},
+		"\x0Aa\x00\x0Ac\x00\x0Ab\x00\x0Ad\x00\x0Af\x00\x0Ae\x00"},
+
+	{&struct{ V bson.Raw }{bson.Raw{0x03, []byte("\x0f\x00\x00\x00\x10byte\x00\b\x00\x00\x00\x00")}},
+		"\x03v\x00" + "\x0f\x00\x00\x00\x10byte\x00\b\x00\x00\x00\x00"},
+	{&struct{ V bson.Raw }{bson.Raw{0x10, []byte("\x00\x00\x00\x00")}},
+		"\x10v\x00" + "\x00\x00\x00\x00"},
+
+	// Byte arrays.
+	{&struct{ V [2]byte }{[2]byte{'y', 'o'}},
+		"\x05v\x00\x02\x00\x00\x00\x00yo"},
+}
+
+
+func (s *S) TestMarshalStructItems(c *C) {
+	for i, item := range structItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, wrapInDoc(item.data),
+			Bug("Failed on item %d", i))
+	}
+}
+
+func (s *S) TestUnmarshalStructItems(c *C) {
+	for _, item := range structItems {
+		testUnmarshal(c, wrapInDoc(item.data), item.obj)
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// One-way marshaling tests.
+
+type dOnIface struct {
+	D interface{}
+}
+
+var marshalItems = []testItemType{
+	// Ordered document dump.  Will unmarshal as a dictionary by default.
+	{bson.D{{"a", nil}, {"c", nil}, {"b", nil}, {"d", nil}, {"f", nil}, {"e", true}},
+		"\x0Aa\x00\x0Ac\x00\x0Ab\x00\x0Ad\x00\x0Af\x00\x08e\x00\x01"},
+	{&dOnIface{bson.D{{"a", nil}, {"c", nil}, {"b", nil}, {"d", true}}},
+		"\x03d\x00" + wrapInDoc("\x0Aa\x00\x0Ac\x00\x0Ab\x00\x08d\x00\x01")},
+
+	// Marshalling a Raw document does nothing.
+	{bson.Raw{0x03, []byte(wrapInDoc("anything"))},
+		"anything"},
+	{bson.Raw{Data: []byte(wrapInDoc("anything"))},
+		"anything"},
+}
+
+func (s *S) TestMarshalOneWayItems(c *C) {
+	for _, item := range marshalItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, wrapInDoc(item.data))
+	}
+}
+
+// --------------------------------------------------------------------------
+// One-way unmarshaling tests.
+
+var unmarshalItems = []testItemType{
+	// Field is private.  Should not attempt to unmarshal it.
+	{&struct{ priv byte }{},
+		"\x10priv\x00\x08\x00\x00\x00"},
+
+	// Wrong casing. Field names are lowercased.
+	{&struct{ Byte byte }{},
+		"\x10Byte\x00\x08\x00\x00\x00"},
+
+	// Ignore non-existing field.
+	{&struct{ Byte byte }{9},
+		"\x10boot\x00\x08\x00\x00\x00" + "\x10byte\x00\x09\x00\x00\x00"},
+
+	// Ignore unsuitable types silently.
+	{map[string]string{"str": "s"},
+		"\x02str\x00\x02\x00\x00\x00s\x00" + "\x10int\x00\x01\x00\x00\x00"},
+	{map[string][]int{"array": []int{5, 9}},
+		"\x04array\x00" +
+			wrapInDoc("\x100\x00\x05\x00\x00\x00"+
+				"\x021\x00\x02\x00\x00\x00s\x00"+
+				"\x102\x00\x09\x00\x00\x00")},
+
+	// Wrong type. Shouldn't init pointer.
+	{&struct{ Str *byte }{},
+		"\x02str\x00\x02\x00\x00\x00s\x00"},
+	{&struct{ Str *struct{ Str string } }{},
+		"\x02str\x00\x02\x00\x00\x00s\x00"},
+
+	// Ordered document.
+	{&struct{ bson.D }{bson.D{{"a", nil}, {"c", nil}, {"b", nil}, {"d", true}}},
+		"\x03d\x00" + wrapInDoc("\x0Aa\x00\x0Ac\x00\x0Ab\x00\x08d\x00\x01")},
+
+	// Raw document.
+	{&bson.Raw{0x03, []byte(wrapInDoc("\x10byte\x00\x08\x00\x00\x00"))},
+		"\x10byte\x00\x08\x00\x00\x00"},
+}
+
+
+func (s *S) TestUnmarshalOneWayItems(c *C) {
+	for _, item := range unmarshalItems {
+		testUnmarshal(c, wrapInDoc(item.data), item.obj)
+	}
+}
+
+func (s *S) TestUnmarshalNilInStruct(c *C) {
+	// Nil is the default value, so we need to ensure it's indeed being set.
+	b := byte(1)
+	v := &struct{ Ptr *byte }{&b}
+	err := bson.Unmarshal([]byte(wrapInDoc("\x0Aptr\x00")), v)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, &struct{ Ptr *byte }{nil})
+}
+
+// --------------------------------------------------------------------------
+// Marshalling error cases.
+
+type structWithDupKeys struct {
+	Name  byte
+	Other byte "name" // Tag should precede.
+}
+
+var marshalErrorItems = []testItemType{
+	{bson.M{"": uint64(1 << 63)},
+		"BSON has no uint64 type, and value is too large to fit correctly in an int64"},
+	{bson.M{"": bson.ObjectId("tooshort")},
+		"ObjectIDs must be exactly 12 bytes long \\(got 8\\)"},
+	{int64(123),
+		"Can't marshal int64 as a BSON document"},
+	{bson.M{"": 1i},
+		"Can't marshal complex128 in a BSON document"},
+	{&structWithDupKeys{},
+		"Duplicated key 'name' in struct bson_test.structWithDupKeys"},
+	{bson.Raw{0x0A, []byte{}},
+		"Attempted to unmarshal Raw kind 10 as a document"},
+}
+
+func (s *S) TestMarshalErrorItems(c *C) {
+	for _, item := range marshalErrorItems {
+		data, err := bson.Marshal(item.obj)
+		c.Assert(err, Matches, item.data)
+		c.Assert(data, IsNil)
+	}
+}
+
+// --------------------------------------------------------------------------
+// Unmarshalling error cases.
+
+type unmarshalErrorType struct {
+	obj   interface{}
+	data  string
+	error string
+}
+
+var unmarshalErrorItems = []unmarshalErrorType{
+	// Tag name conflicts with existing parameter.
+	{&structWithDupKeys{},
+		"\x10name\x00\x08\x00\x00\x00",
+		"Duplicated key 'name' in struct bson_test.structWithDupKeys"},
+
+	// Non-string map key.
+	{map[int]interface{}{},
+		"\x10name\x00\x08\x00\x00\x00",
+		"BSON map must have string keys. Got: map\\[int\\] interface \\{ \\}"},
+
+	{nil,
+		"\xEEname\x00",
+		"Unknown element kind \\(0xEE\\)"},
+
+	{struct{ Name bool }{},
+		"\x10name\x00\x08\x00\x00\x00",
+		"Unmarshal can't deal with struct values. Use a pointer."},
+
+	{123,
+		"\x10name\x00\x08\x00\x00\x00",
+		"Unmarshal needs a map or a pointer to a struct."},
+}
+
+
+func (s *S) TestUnmarshalErrorItems(c *C) {
+	for _, item := range unmarshalErrorItems {
+		data := []byte(wrapInDoc(item.data))
+		var value interface{}
+		switch reflect.ValueOf(item.obj).Kind() {
+		case reflect.Map, reflect.Ptr:
+			value = makeZeroDoc(item.obj)
+		case reflect.Invalid:
+			value = bson.M{}
+		default:
+			value = item.obj
+		}
+		err := bson.Unmarshal(data, value)
+		c.Assert(err, Matches, item.error)
+	}
+}
+
+
+type unmarshalRawErrorType struct {
+	obj   interface{}
+	raw   bson.Raw
+	error string
+}
+
+var unmarshalRawErrorItems = []unmarshalRawErrorType{
+	// Tag name conflicts with existing parameter.
+	{&structWithDupKeys{},
+		bson.Raw{0x03, []byte("\x10byte\x00\x08\x00\x00\x00")},
+		"Duplicated key 'name' in struct bson_test.structWithDupKeys"},
+
+	{&struct{}{},
+		bson.Raw{0xEE, []byte{}},
+		"Unknown element kind \\(0xEE\\)"},
+
+	{struct{ Name bool }{},
+		bson.Raw{0x10, []byte("\x08\x00\x00\x00")},
+		"Raw Unmarshal needs a map or a valid pointer."},
+
+	{123,
+		bson.Raw{0x10, []byte("\x08\x00\x00\x00")},
+		"Raw Unmarshal needs a map or a valid pointer."},
+}
+
+func (s *S) TestUnmarshalRawErrorItems(c *C) {
+	for i, item := range unmarshalRawErrorItems {
+		err := item.raw.Unmarshal(item.obj)
+		c.Assert(err, Matches, item.error, Bug("Failed on item %d: %#v\n", i, item))
+	}
+}
+
+var corruptedData = []string{
+	"\x04\x00\x00\x00\x00",         // Shorter than minimum
+	"\x06\x00\x00\x00\x00",         // Not enough data
+	"\x05\x00\x00",                 // Broken length
+	"\x05\x00\x00\x00\xff",         // Corrupted termination
+	"\x0A\x00\x00\x00\x0Aooop\x00", // Unfinished C string
+
+	// Array end past end of string (s[2]=0x07 is correct)
+	wrapInDoc("\x04\x00\x09\x00\x00\x00\x0A\x00\x00"),
+
+	// Array end within string, but past acceptable.
+	wrapInDoc("\x04\x00\x08\x00\x00\x00\x0A\x00\x00"),
+
+	// Document end within string, but past acceptable.
+	wrapInDoc("\x03\x00\x08\x00\x00\x00\x0A\x00\x00"),
+
+	// String with corrupted end.
+	wrapInDoc("\x02\x00\x03\x00\x00\x00yo\xFF"),
+}
+
+
+func (s *S) TestUnmarshalMapDocumentTooShort(c *C) {
+	for _, data := range corruptedData {
+		err := bson.Unmarshal([]byte(data), bson.M{})
+		c.Assert(err, Matches, "Document is corrupted")
+
+		err = bson.Unmarshal([]byte(data), &struct{}{})
+		c.Assert(err, Matches, "Document is corrupted")
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Setter test cases.
+
+var setterResult = map[string]bool{}
+
+type typeWithSetter struct {
+	received interface{}
+}
+
+func (o *typeWithSetter) SetBSON(value interface{}) (ok bool) {
+	o.received = value
+	if s, ok := value.(string); ok {
+		if result, ok := setterResult[s]; ok {
+			return result
+		}
+	}
+	return true
+}
+
+type docWithSetterField struct {
+	Field *typeWithSetter "_"
+}
+
+func (s *S) TestUnmarshalAllItemsWithSetter(c *C) {
+	for _, item := range allItems {
+		obj := &docWithSetterField{}
+		err := bson.Unmarshal([]byte(wrapInDoc(item.data)), obj)
+		c.Assert(err, IsNil)
+
+		if item.data == "" {
+			// Nothing to unmarshal. Should be untouched.
+			c.Assert(obj.Field, IsNil)
+		} else {
+			expected := item.obj.(bson.M)["_"]
+
+			if m, ok := expected.(bson.M); ok {
+				// Setter works with a bson.D slice rather than bson.M.
+				slice := make(bson.D, 0, len(m))
+				for key, value := range m {
+					slice = append(slice, bson.DocElem{key, value})
+				}
+				expected = slice
+			}
+
+			c.Assert(obj.Field, NotNil,
+				Bug("Pointer not initialized (%#v)", expected))
+			c.Assert(obj.Field.received, Equals, expected)
+		}
+	}
+}
+
+func (s *S) TestUnmarshalWholeDocumentWithSetter(c *C) {
+	obj := &typeWithSetter{}
+	err := bson.Unmarshal([]byte(sampleItems[0].data), obj)
+	c.Assert(err, IsNil)
+	c.Assert(obj.received, Equals, bson.D{{"hello", "world"}})
+}
+
+func (s *S) TestUnmarshalWithFalseSetterIgnoresValue(c *C) {
+	setterResult["2"] = false
+	setterResult["4"] = false
+	defer func() {
+		setterResult["2"] = false, false
+		setterResult["4"] = false, false
+	}()
+
+	m := map[string]*typeWithSetter{}
+	data := wrapInDoc("\x02abc\x00\x02\x00\x00\x001\x00" +
+		"\x02def\x00\x02\x00\x00\x002\x00" +
+		"\x02ghi\x00\x02\x00\x00\x003\x00" +
+		"\x02jkl\x00\x02\x00\x00\x004\x00")
+	err := bson.Unmarshal([]byte(data), m)
+	c.Assert(err, IsNil)
+	c.Assert(m["abc"], NotNil)
+	c.Assert(m["def"], IsNil)
+	c.Assert(m["ghi"], NotNil)
+	c.Assert(m["jkl"], IsNil)
+
+	c.Assert(m["abc"].received, Equals, "1")
+	c.Assert(m["ghi"].received, Equals, "3")
+}
+
+func (s *S) TestDMap(c *C) {
+	d := bson.D{{"a", 1}, {"b", 2}}
+	c.Assert(d.Map(), Equals, bson.M{"a": 1, "b": 2})
+}
+
+
+// --------------------------------------------------------------------------
+// Getter test cases.
+
+type typeWithGetter struct {
+	result interface{}
+}
+
+func (t *typeWithGetter) GetBSON() interface{} {
+	return t.result
+}
+
+type docWithGetterField struct {
+	Field *typeWithGetter "_"
+}
+
+func (s *S) TestMarshalAllItemsWithGetter(c *C) {
+	for i, item := range allItems {
+		if item.data == "" {
+			continue
+		}
+		obj := &docWithGetterField{}
+		obj.Field = &typeWithGetter{item.obj.(bson.M)["_"]}
+		data, err := bson.Marshal(obj)
+		c.Assert(err, IsNil)
+		c.Assert(string(data), Equals, wrapInDoc(item.data),
+			Bug("Failed on item #%d", i))
+	}
+}
+
+func (s *S) TestMarshalWholeDocumentWithGetter(c *C) {
+	obj := &typeWithGetter{sampleItems[0].obj}
+	data, err := bson.Marshal(obj)
+	c.Assert(err, IsNil)
+	c.Assert(string(data), Equals, sampleItems[0].data)
+}
+
+type intGetter int64
+
+func (t intGetter) GetBSON() interface{} {
+	return int64(t)
+}
+
+type typeWithIntGetter struct {
+	V intGetter "/s"
+}
+
+func (s *S) TestMarshalShortWithGetter(c *C) {
+	obj := typeWithIntGetter{42}
+	data, err := bson.Marshal(obj)
+	c.Assert(err, IsNil)
+	m := bson.M{}
+	err = bson.Unmarshal(data, m)
+	c.Assert(m["v"], Equals, 42)
+}
+
+// --------------------------------------------------------------------------
+// Cross-type conversion tests.
+
+type crossTypeItem struct {
+	obj1 interface{}
+	obj2 interface{}
+}
+
+type condStr struct {
+	V string "/c"
+}
+type condBool struct {
+	V bool "/c"
+}
+type condInt struct {
+	V int "/c"
+}
+type condUInt struct {
+	V uint "/c"
+}
+type condIface struct {
+	V interface{} "/c"
+}
+type condPtr struct {
+	V *bool "/c"
+}
+type condSlice struct {
+	V []string "/c"
+}
+type condMap struct {
+	V map[string]int "/c"
+}
+type namedCondStr struct {
+	V string "myv/c"
+}
+
+type shortInt struct {
+	V int64 "/s"
+}
+type shortUint struct {
+	V uint64 "/s"
+}
+type shortIface struct {
+	V interface{} "/s"
+}
+type shortPtr struct {
+	V *int64 "/s"
+}
+
+type slashedName struct {
+	V string "a/b/"
+}
+
+var truevar = true
+var falsevar = false
+
+var int64var = int64(42)
+var int64ptr = &int64var
+var intvar = int(42)
+var intptr = &intvar
+
+// That's a pretty fun test.  It will dump the first item, generate a zero
+// value equivalent to the second one, load the dumped data onto it, and then
+// verify that the resulting value is deep-equal to the untouched second value.
+// Then, it will do the same in the *opposite* direction!
+var twoWayCrossItems = []crossTypeItem{
+	// int<=>int
+	{&struct{ I int }{42}, &struct{ I int8 }{42}},
+	{&struct{ I int }{42}, &struct{ I int32 }{42}},
+	{&struct{ I int }{42}, &struct{ I int64 }{42}},
+	{&struct{ I int8 }{42}, &struct{ I int32 }{42}},
+	{&struct{ I int8 }{42}, &struct{ I int64 }{42}},
+	{&struct{ I int32 }{42}, &struct{ I int64 }{42}},
+
+	// uint<=>uint
+	{&struct{ I uint }{42}, &struct{ I uint8 }{42}},
+	{&struct{ I uint }{42}, &struct{ I uint32 }{42}},
+	{&struct{ I uint }{42}, &struct{ I uint64 }{42}},
+	{&struct{ I uint8 }{42}, &struct{ I uint32 }{42}},
+	{&struct{ I uint8 }{42}, &struct{ I uint64 }{42}},
+	{&struct{ I uint32 }{42}, &struct{ I uint64 }{42}},
+
+	// float32<=>float64
+	{&struct{ I float32 }{42}, &struct{ I float64 }{42}},
+
+	// int<=>uint
+	{&struct{ I uint }{42}, &struct{ I int }{42}},
+	{&struct{ I uint }{42}, &struct{ I int8 }{42}},
+	{&struct{ I uint }{42}, &struct{ I int32 }{42}},
+	{&struct{ I uint }{42}, &struct{ I int64 }{42}},
+	{&struct{ I uint8 }{42}, &struct{ I int }{42}},
+	{&struct{ I uint8 }{42}, &struct{ I int8 }{42}},
+	{&struct{ I uint8 }{42}, &struct{ I int32 }{42}},
+	{&struct{ I uint8 }{42}, &struct{ I int64 }{42}},
+	{&struct{ I uint32 }{42}, &struct{ I int }{42}},
+	{&struct{ I uint32 }{42}, &struct{ I int8 }{42}},
+	{&struct{ I uint32 }{42}, &struct{ I int32 }{42}},
+	{&struct{ I uint32 }{42}, &struct{ I int64 }{42}},
+	{&struct{ I uint64 }{42}, &struct{ I int }{42}},
+	{&struct{ I uint64 }{42}, &struct{ I int8 }{42}},
+	{&struct{ I uint64 }{42}, &struct{ I int32 }{42}},
+	{&struct{ I uint64 }{42}, &struct{ I int64 }{42}},
+
+	// int <=> timestamp.  Note the NS <=> MS conversion.
+	{&struct{ I bson.Timestamp }{42e6}, &struct{ I int64 }{42}},
+	{&struct{ I bson.Timestamp }{42e6}, &struct{ I int32 }{42}},
+	{&struct{ I bson.Timestamp }{42e6}, &struct{ I int }{42}},
+
+	// int <=> float
+	{&struct{ I int }{42}, &struct{ I float64 }{42}},
+
+	// int <=> bool
+	{&struct{ I int }{1}, &struct{ I bool }{true}},
+	{&struct{ I int }{0}, &struct{ I bool }{false}},
+
+	// uint <=> float64
+	{&struct{ I uint }{42}, &struct{ I float64 }{42}},
+
+	// uint <=> bool
+	{&struct{ I uint }{1}, &struct{ I bool }{true}},
+	{&struct{ I uint }{0}, &struct{ I bool }{false}},
+
+	// float64 <=> bool
+	{&struct{ I float64 }{1}, &struct{ I bool }{true}},
+	{&struct{ I float64 }{0}, &struct{ I bool }{false}},
+
+	// string <=> string and string <=> []byte
+	{&struct{ S []byte }{[]byte("abc")}, &struct{ S string }{"abc"}},
+	{&struct{ S []byte }{[]byte("def")}, &struct{ S bson.Symbol }{"def"}},
+	{&struct{ S string }{"ghi"}, &struct{ S bson.Symbol }{"ghi"}},
+
+	// map <=> struct
+	{&struct {
+		A struct {
+			B, C int
+		}
+	}{struct{ B, C int }{1, 2}},
+		map[string]map[string]int{"a": map[string]int{"b": 1, "c": 2}}},
+
+	{&struct{ A bson.Symbol }{"abc"}, map[string]string{"a": "abc"}},
+	{&struct{ A bson.Symbol }{"abc"}, map[string][]byte{"a": []byte("abc")}},
+	{&struct{ A []byte }{[]byte("abc")}, map[string]string{"a": "abc"}},
+	{&struct{ A uint }{42}, map[string]int{"a": 42}},
+	{&struct{ A uint }{42}, map[string]float64{"a": 42}},
+	{&struct{ A uint }{1}, map[string]bool{"a": true}},
+	{&struct{ A int }{42}, map[string]uint{"a": 42}},
+	{&struct{ A int }{42}, map[string]float64{"a": 42}},
+	{&struct{ A int }{1}, map[string]bool{"a": true}},
+	{&struct{ A float64 }{42}, map[string]float32{"a": 42}},
+	{&struct{ A float64 }{42}, map[string]int{"a": 42}},
+	{&struct{ A float64 }{42}, map[string]uint{"a": 42}},
+	{&struct{ A float64 }{1}, map[string]bool{"a": true}},
+	{&struct{ A bool }{true}, map[string]int{"a": 1}},
+	{&struct{ A bool }{true}, map[string]uint{"a": 1}},
+	{&struct{ A bool }{true}, map[string]float64{"a": 1}},
+	{&struct{ A **byte }{&byteptr}, map[string]byte{"a": 8}},
+
+	// Slices
+	{&struct{ S []int }{[]int{1, 2, 3}}, map[string][]int{"s": []int{1, 2, 3}}},
+	{&struct{ S *[]int }{&[]int{1, 2, 3}}, map[string][]int{"s": []int{1, 2, 3}}},
+
+	// Conditionals
+	{&condBool{true}, map[string]bool{"v": true}},
+	{&condBool{}, map[string]bool{}},
+	{&condInt{1}, map[string]int{"v": 1}},
+	{&condInt{}, map[string]int{}},
+	{&condUInt{1}, map[string]uint{"v": 1}},
+	{&condUInt{}, map[string]uint{}},
+	{&condStr{"yo"}, map[string]string{"v": "yo"}},
+	{&condStr{}, map[string]string{}},
+	{&condSlice{[]string{"yo"}}, map[string][]string{"v": []string{"yo"}}},
+	{&condSlice{}, map[string][]string{}},
+	{&condMap{map[string]int{"k": 1}}, bson.M{"v": bson.M{"k": 1}}},
+	{&condMap{map[string]int{}}, map[string][]string{}},
+	{&condMap{}, map[string][]string{}},
+	{&condIface{"yo"}, map[string]string{"v": "yo"}},
+	{&condIface{""}, map[string]string{"v": ""}},
+	{&condIface{}, map[string]string{}},
+	{&condPtr{&truevar}, map[string]bool{"v": true}},
+	{&condPtr{&falsevar}, map[string]bool{"v": false}},
+	{&condPtr{}, map[string]string{}},
+
+	{&namedCondStr{"yo"}, map[string]string{"myv": "yo"}},
+	{&namedCondStr{}, map[string]string{}},
+
+	{&shortInt{1}, map[string]interface{}{"v": 1}},
+	{&shortInt{1 << 30}, map[string]interface{}{"v": 1 << 30}},
+	{&shortInt{1 << 31}, map[string]interface{}{"v": int64(1 << 31)}},
+	{&shortUint{1 << 30}, map[string]interface{}{"v": 1 << 30}},
+	{&shortUint{1 << 31}, map[string]interface{}{"v": int64(1 << 31)}},
+	{&shortIface{int64(1) << 31}, map[string]interface{}{"v": int64(1 << 31)}},
+	{&shortPtr{int64ptr}, map[string]interface{}{"v": intvar}},
+
+	{&slashedName{"yo"}, map[string]string{"a/b": "yo"}},
+}
+
+// Same thing, but only one way (obj1 => obj2).
+var oneWayCrossItems = []crossTypeItem{
+	// map <=> struct
+	{map[string]interface{}{"a": 1, "b": "2", "c": 3},
+		map[string]int{"a": 1, "c": 3}},
+
+	// Can't decode int into struct.
+	{bson.M{"a": bson.M{"b": 2}}, &struct{ A bool }{}},
+
+	// Would get decoded into a int32 too in the opposite direction.
+	{&shortIface{int64(1) << 30}, map[string]interface{}{"v": 1 << 30}},
+}
+
+func testCrossPair(c *C, dump interface{}, load interface{}, bug interface{}) {
+	//c.Logf("")
+	zero := makeZeroDoc(load)
+	data, err := bson.Marshal(dump)
+	c.Assert(err, IsNil, bug)
+	c.Logf("Data: %#v", string(data))
+	err = bson.Unmarshal(data, zero)
+	c.Assert(err, IsNil, bug)
+	c.Assert(zero, Equals, load, bug)
+}
+
+func (s *S) TestTwoWayCrossPairs(c *C) {
+	for i, item := range twoWayCrossItems {
+		testCrossPair(c, item.obj1, item.obj2, Bug("#%d obj1 => obj2", i))
+		testCrossPair(c, item.obj2, item.obj1, Bug("#%d obj1 <= obj2", i))
+	}
+}
+
+func (s *S) TestOneWayCrossPairs(c *C) {
+	for i, item := range oneWayCrossItems {
+		testCrossPair(c, item.obj1, item.obj2, Bug("#%d obj1 => obj2", i))
+	}
+}
+
+// --------------------------------------------------------------------------
+// ObjectId hex representation test.
+
+func (s *S) TestObjectIdHex(c *C) {
+	id := bson.ObjectIdHex("4d88e15b60f486e428412dc9")
+	str := "ObjectIdHex(\"4d88e15b60f486e428412dc9\")"
+	c.Assert(str, Equals, id.String())
+}
+
+// --------------------------------------------------------------------------
+// ObjectId parts extraction tests.
+
+type objectIdParts struct {
+	id        bson.ObjectId
+	timestamp int32
+	machine   []byte
+	pid       uint16
+	counter   int32
+}
+
+var objectIds = []objectIdParts{
+	objectIdParts{
+		bson.ObjectIdHex("4d88e15b60f486e428412dc9"),
+		1300816219,
+		[]byte{0x60, 0xf4, 0x86},
+		0xe428,
+		4271561,
+	},
+	objectIdParts{
+		bson.ObjectIdHex("000000000000000000000000"),
+		0,
+		[]byte{0x00, 0x00, 0x00},
+		0x0000,
+		0,
+	},
+	objectIdParts{
+		bson.ObjectIdHex("00000000aabbccddee000001"),
+		0,
+		[]byte{0xaa, 0xbb, 0xcc},
+		0xddee,
+		1,
+	},
+}
+
+func (s *S) TestObjectIdPartsExtraction(c *C) {
+	for i, v := range objectIds {
+		c.Assert(v.id.Timestamp(), Equals, v.timestamp, Bug("#%d Wrong timestamp value", i))
+		c.Assert(v.id.Machine(), Equals, v.machine, Bug("#%d Wrong machine id value", i))
+		c.Assert(v.id.Pid(), Equals, v.pid, Bug("#%d Wrong pid value", i))
+		c.Assert(v.id.Counter(), Equals, v.counter, Bug("#%d Wrong counter value", i))
+	}
+}
+
+func (s *S) TestNow(c *C) {
+	before := time.Nanoseconds()
+	time.Sleep(1e6)
+	now := bson.Now()
+	time.Sleep(1e6)
+	after := time.Nanoseconds()
+	c.Assert(reflect.TypeOf(now), Equals, reflect.TypeOf(bson.Timestamp(00)))
+	c.Assert(int64(now) > before && int64(now) < after, Equals, true, Bug("now=%d, before=%d, after=%d", now, before, after))
+}
+
+// --------------------------------------------------------------------------
+// ObjectId generation tests.
+
+func (s *S) TestNewObjectId(c *C) {
+	// Generate 10 ids
+	ids := make([]bson.ObjectId, 10)
+	for i := 0; i < 10; i++ {
+		ids[i] = bson.NewObjectId()
+	}
+	for i := 1; i < 10; i++ {
+		prevId := ids[i-1]
+		id := ids[i]
+		// Test for uniqueness among all other 9 generated ids
+		for j, tid := range ids {
+			if j != i {
+				c.Assert(id, Not(Equals), tid, Bug("Generated ObjectId is not unique"))
+			}
+		}
+		// Check that timestamp was incremented and is within 30 seconds of the previous one
+		td := id.Timestamp() - prevId.Timestamp()
+		c.Assert((td >= 0 && td <= 30), Equals, true, Bug("Wrong timestamp in generated ObjectId"))
+		// Check that machine ids are the same
+		c.Assert(id.Machine(), Equals, prevId.Machine())
+		// Check that pids are the same
+		c.Assert(id.Pid(), Equals, prevId.Pid())
+		// Test for proper increment
+		delta := int(id.Counter() - prevId.Counter())
+		c.Assert(delta, Equals, 1, Bug("Wrong increment in generated ObjectId"))
+	}
+}
+
+func (s *S) TestNewObjectIdSeconds(c *C) {
+	sec := int32(time.Seconds())
+	id := bson.NewObjectIdSeconds(sec)
+	c.Assert(id.Timestamp(), Equals, sec)
+	c.Assert(id.Machine(), Equals, []byte{0x00, 0x00, 0x00})
+	c.Assert(int(id.Pid()), Equals, 0)
+	c.Assert(int(id.Counter()), Equals, 0)
+}