// Copyright (C) MongoDB, Inc. 2017-present. // // Licensed under the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. You may obtain // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 package bsoncodec import ( "bytes" "encoding/json" "errors" "fmt" "math" "net/url" "reflect" "strings" "testing" "time" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsonrw/bsonrwtest" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) var ( defaultTestStructCodec = newDefaultStructCodec() ) func TestDefaultValueDecoders(t *testing.T) { var dvd DefaultValueDecoders var wrong = func(string, string) string { return "wrong" } type mybool bool type myint8 int8 type myint16 int16 type myint32 int32 type myint64 int64 type myint int type myuint8 uint8 type myuint16 uint16 type myuint32 uint32 type myuint64 uint64 type myuint uint type myfloat32 float32 type myfloat64 float64 type mystring string type mystruct struct{} const cansetreflectiontest = "cansetreflectiontest" const cansettest = "cansettest" now := time.Now().Truncate(time.Millisecond) d128 := primitive.NewDecimal128(12345, 67890) var pbool = func(b bool) *bool { return &b } var pi32 = func(i32 int32) *int32 { return &i32 } var pi64 = func(i64 int64) *int64 { return &i64 } type subtest struct { name string val interface{} dctx *DecodeContext llvrw *bsonrwtest.ValueReaderWriter invoke bsonrwtest.Invoked err error } testCases := []struct { name string vd ValueDecoder subtests []subtest }{ { "BooleanDecodeValue", ValueDecoderFunc(dvd.BooleanDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Boolean}, bsonrwtest.Nothing, ValueDecoderError{Name: "BooleanDecodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: reflect.ValueOf(wrong)}, }, { "type not boolean", bool(false), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a boolean", bsontype.String), }, { "fast path", bool(true), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Boolean, Return: bool(true)}, bsonrwtest.ReadBoolean, nil, }, { "reflection path", mybool(true), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Boolean, Return: bool(true)}, bsonrwtest.ReadBoolean, nil, }, { "reflection path error", mybool(true), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Boolean, Return: bool(true), Err: errors.New("ReadBoolean Error"), ErrAfter: bsonrwtest.ReadBoolean}, bsonrwtest.ReadBoolean, errors.New("ReadBoolean Error"), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Boolean}, bsonrwtest.Nothing, ValueDecoderError{Name: "BooleanDecodeValue", Kinds: []reflect.Kind{reflect.Bool}}, }, { "decode null", mybool(false), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", mybool(false), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "IntDecodeValue", ValueDecoderFunc(dvd.IntDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, Received: reflect.ValueOf(wrong), }, }, { "type not int32/int64", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into an integer type", bsontype.String), }, { "ReadInt32 error", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0), Err: errors.New("ReadInt32 error"), ErrAfter: bsonrwtest.ReadInt32}, bsonrwtest.ReadInt32, errors.New("ReadInt32 error"), }, { "ReadInt64 error", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(0), Err: errors.New("ReadInt64 error"), ErrAfter: bsonrwtest.ReadInt64}, bsonrwtest.ReadInt64, errors.New("ReadInt64 error"), }, { "ReadDouble error", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0), Err: errors.New("ReadDouble error"), ErrAfter: bsonrwtest.ReadDouble}, bsonrwtest.ReadDouble, errors.New("ReadDouble error"), }, { "ReadDouble", int64(3), &DecodeContext{}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.00)}, bsonrwtest.ReadDouble, nil, }, { "ReadDouble (truncate)", int64(3), &DecodeContext{Truncate: true}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, nil, }, { "ReadDouble (no truncate)", int64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, errCannotTruncate, }, { "ReadDouble overflows int64", int64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: math.MaxFloat64}, bsonrwtest.ReadDouble, fmt.Errorf("%g overflows int64", math.MaxFloat64), }, {"int8/fast path", int8(127), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(127)}, bsonrwtest.ReadInt32, nil}, {"int16/fast path", int16(32676), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(32676)}, bsonrwtest.ReadInt32, nil}, {"int32/fast path", int32(1234), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1234)}, bsonrwtest.ReadInt32, nil}, {"int64/fast path", int64(1234), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1234)}, bsonrwtest.ReadInt64, nil}, {"int/fast path", int(1234), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1234)}, bsonrwtest.ReadInt64, nil}, { "int8/fast path - nil", (*int8)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, Received: reflect.ValueOf((*int8)(nil)), }, }, { "int16/fast path - nil", (*int16)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, Received: reflect.ValueOf((*int16)(nil)), }, }, { "int32/fast path - nil", (*int32)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, Received: reflect.ValueOf((*int32)(nil)), }, }, { "int64/fast path - nil", (*int64)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, Received: reflect.ValueOf((*int64)(nil)), }, }, { "int/fast path - nil", (*int)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, Received: reflect.ValueOf((*int)(nil)), }, }, { "int8/fast path - overflow", int8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(129)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int8", 129), }, { "int16/fast path - overflow", int16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(32768)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int16", 32768), }, { "int32/fast path - overflow", int32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(2147483648)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows int32", int64(2147483648)), }, { "int8/fast path - overflow (negative)", int8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-129)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int8", -129), }, { "int16/fast path - overflow (negative)", int16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-32769)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int16", -32769), }, { "int32/fast path - overflow (negative)", int32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-2147483649)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows int32", int64(-2147483649)), }, { "int8/reflection path", myint8(127), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(127)}, bsonrwtest.ReadInt32, nil, }, { "int16/reflection path", myint16(255), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(255)}, bsonrwtest.ReadInt32, nil, }, { "int32/reflection path", myint32(511), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(511)}, bsonrwtest.ReadInt32, nil, }, { "int64/reflection path", myint64(1023), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1023)}, bsonrwtest.ReadInt32, nil, }, { "int/reflection path", myint(2047), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(2047)}, bsonrwtest.ReadInt32, nil, }, { "int8/reflection path - overflow", myint8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(129)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int8", 129), }, { "int16/reflection path - overflow", myint16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(32768)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int16", 32768), }, { "int32/reflection path - overflow", myint32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(2147483648)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows int32", int64(2147483648)), }, { "int8/reflection path - overflow (negative)", myint8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-129)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int8", -129), }, { "int16/reflection path - overflow (negative)", myint16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-32769)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows int16", -32769), }, { "int32/reflection path - overflow (negative)", myint32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-2147483649)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows int32", int64(-2147483649)), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.Nothing, ValueDecoderError{ Name: "IntDecodeValue", Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int}, }, }, { "decode null", myint(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", myint(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "defaultUIntCodec.DecodeValue", defaultUIntCodec, []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, Received: reflect.ValueOf(wrong), }, }, { "type not int32/int64", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into an integer type", bsontype.String), }, { "ReadInt32 error", uint(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0), Err: errors.New("ReadInt32 error"), ErrAfter: bsonrwtest.ReadInt32}, bsonrwtest.ReadInt32, errors.New("ReadInt32 error"), }, { "ReadInt64 error", uint(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(0), Err: errors.New("ReadInt64 error"), ErrAfter: bsonrwtest.ReadInt64}, bsonrwtest.ReadInt64, errors.New("ReadInt64 error"), }, { "ReadDouble error", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0), Err: errors.New("ReadDouble error"), ErrAfter: bsonrwtest.ReadDouble}, bsonrwtest.ReadDouble, errors.New("ReadDouble error"), }, { "ReadDouble", uint64(3), &DecodeContext{}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.00)}, bsonrwtest.ReadDouble, nil, }, { "ReadDouble (truncate)", uint64(3), &DecodeContext{Truncate: true}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, nil, }, { "ReadDouble (no truncate)", uint64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, errCannotTruncate, }, { "ReadDouble overflows int64", uint64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: math.MaxFloat64}, bsonrwtest.ReadDouble, fmt.Errorf("%g overflows int64", math.MaxFloat64), }, {"uint8/fast path", uint8(127), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(127)}, bsonrwtest.ReadInt32, nil}, {"uint16/fast path", uint16(255), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(255)}, bsonrwtest.ReadInt32, nil}, {"uint32/fast path", uint32(1234), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1234)}, bsonrwtest.ReadInt32, nil}, {"uint64/fast path", uint64(1234), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1234)}, bsonrwtest.ReadInt64, nil}, {"uint/fast path", uint(1234), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1234)}, bsonrwtest.ReadInt64, nil}, { "uint8/fast path - nil", (*uint8)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, Received: reflect.ValueOf((*uint8)(nil)), }, }, { "uint16/fast path - nil", (*uint16)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, Received: reflect.ValueOf((*uint16)(nil)), }, }, { "uint32/fast path - nil", (*uint32)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, Received: reflect.ValueOf((*uint32)(nil)), }, }, { "uint64/fast path - nil", (*uint64)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, Received: reflect.ValueOf((*uint64)(nil)), }, }, { "uint/fast path - nil", (*uint)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.ReadInt32, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, Received: reflect.ValueOf((*uint)(nil)), }, }, { "uint8/fast path - overflow", uint8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1 << 8)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint8", 1<<8), }, { "uint16/fast path - overflow", uint16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1 << 16)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint16", 1<<16), }, { "uint32/fast path - overflow", uint32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1 << 32)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint32", int64(1<<32)), }, { "uint8/fast path - overflow (negative)", uint8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-1)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint8", -1), }, { "uint16/fast path - overflow (negative)", uint16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-1)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint16", -1), }, { "uint32/fast path - overflow (negative)", uint32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-1)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint32", -1), }, { "uint64/fast path - overflow (negative)", uint64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-1)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint64", -1), }, { "uint/fast path - overflow (negative)", uint(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-1)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint", -1), }, { "uint8/reflection path", myuint8(127), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(127)}, bsonrwtest.ReadInt32, nil, }, { "uint16/reflection path", myuint16(255), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(255)}, bsonrwtest.ReadInt32, nil, }, { "uint32/reflection path", myuint32(511), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(511)}, bsonrwtest.ReadInt32, nil, }, { "uint64/reflection path", myuint64(1023), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1023)}, bsonrwtest.ReadInt32, nil, }, { "uint/reflection path", myuint(2047), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(2047)}, bsonrwtest.ReadInt32, nil, }, { "uint8/reflection path - overflow", myuint8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1 << 8)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint8", 1<<8), }, { "uint16/reflection path - overflow", myuint16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(1 << 16)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint16", 1<<16), }, { "uint32/reflection path - overflow", myuint32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1 << 32)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint32", int64(1<<32)), }, { "uint8/reflection path - overflow (negative)", myuint8(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-1)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint8", -1), }, { "uint16/reflection path - overflow (negative)", myuint16(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(-1)}, bsonrwtest.ReadInt32, fmt.Errorf("%d overflows uint16", -1), }, { "uint32/reflection path - overflow (negative)", myuint32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-1)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint32", -1), }, { "uint64/reflection path - overflow (negative)", myuint64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-1)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint64", -1), }, { "uint/reflection path - overflow (negative)", myuint(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(-1)}, bsonrwtest.ReadInt64, fmt.Errorf("%d overflows uint", -1), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0)}, bsonrwtest.Nothing, ValueDecoderError{ Name: "UintDecodeValue", Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint}, }, }, }, }, { "FloatDecodeValue", ValueDecoderFunc(dvd.FloatDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0)}, bsonrwtest.ReadDouble, ValueDecoderError{ Name: "FloatDecodeValue", Kinds: []reflect.Kind{reflect.Float32, reflect.Float64}, Received: reflect.ValueOf(wrong), }, }, { "type not double", 0, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a float32 or float64 type", bsontype.String), }, { "ReadDouble error", float64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0), Err: errors.New("ReadDouble error"), ErrAfter: bsonrwtest.ReadDouble}, bsonrwtest.ReadDouble, errors.New("ReadDouble error"), }, { "ReadInt32 error", float64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(0), Err: errors.New("ReadInt32 error"), ErrAfter: bsonrwtest.ReadInt32}, bsonrwtest.ReadInt32, errors.New("ReadInt32 error"), }, { "ReadInt64 error", float64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(0), Err: errors.New("ReadInt64 error"), ErrAfter: bsonrwtest.ReadInt64}, bsonrwtest.ReadInt64, errors.New("ReadInt64 error"), }, { "float64/int32", float32(32.0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(32)}, bsonrwtest.ReadInt32, nil, }, { "float64/int64", float32(64.0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(64)}, bsonrwtest.ReadInt64, nil, }, { "float32/fast path (equal)", float32(3.0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.0)}, bsonrwtest.ReadDouble, nil, }, { "float64/fast path", float64(3.14159), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14159)}, bsonrwtest.ReadDouble, nil, }, { "float32/fast path (truncate)", float32(3.14), &DecodeContext{Truncate: true}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, nil, }, { "float32/fast path (no truncate)", float32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, errCannotTruncate, }, { "float32/fast path - nil", (*float32)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0)}, bsonrwtest.ReadDouble, ValueDecoderError{ Name: "FloatDecodeValue", Kinds: []reflect.Kind{reflect.Float32, reflect.Float64}, Received: reflect.ValueOf((*float32)(nil)), }, }, { "float64/fast path - nil", (*float64)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0)}, bsonrwtest.ReadDouble, ValueDecoderError{ Name: "FloatDecodeValue", Kinds: []reflect.Kind{reflect.Float32, reflect.Float64}, Received: reflect.ValueOf((*float64)(nil)), }, }, { "float32/reflection path (equal)", myfloat32(3.0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.0)}, bsonrwtest.ReadDouble, nil, }, { "float64/reflection path", myfloat64(3.14159), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14159)}, bsonrwtest.ReadDouble, nil, }, { "float32/reflection path (truncate)", myfloat32(3.14), &DecodeContext{Truncate: true}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, nil, }, { "float32/reflection path (no truncate)", myfloat32(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14)}, bsonrwtest.ReadDouble, errCannotTruncate, }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(0)}, bsonrwtest.Nothing, ValueDecoderError{ Name: "FloatDecodeValue", Kinds: []reflect.Kind{reflect.Float32, reflect.Float64}, }, }, }, }, { "defaultTimeCodec.DecodeValue", defaultTimeCodec, []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: int64(0)}, bsonrwtest.Nothing, ValueDecoderError{Name: "TimeDecodeValue", Types: []reflect.Type{tTime}, Received: reflect.ValueOf(wrong)}, }, { "ReadDateTime error", time.Time{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: int64(0), Err: errors.New("ReadDateTime error"), ErrAfter: bsonrwtest.ReadDateTime}, bsonrwtest.ReadDateTime, errors.New("ReadDateTime error"), }, { "time.Time", now, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: now.UnixNano() / int64(time.Millisecond)}, bsonrwtest.ReadDateTime, nil, }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: int64(0)}, bsonrwtest.Nothing, ValueDecoderError{Name: "TimeDecodeValue", Types: []reflect.Type{tTime}}, }, { "decode null", time.Time{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", time.Time{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "defaultMapCodec.DecodeValue", defaultMapCodec, []subtest{ { "wrong kind", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "MapDecodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: reflect.ValueOf(wrong)}, }, { "wrong kind (non-string key)", map[bool]interface{}{}, &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.ReadElement, fmt.Errorf("unsupported key type: %T", false), }, { "ReadDocument Error", make(map[string]interface{}), nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("rd error"), ErrAfter: bsonrwtest.ReadDocument}, bsonrwtest.ReadDocument, errors.New("rd error"), }, { "Lookup Error", map[string]string{}, &DecodeContext{Registry: NewRegistryBuilder().Build()}, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.ReadDocument, ErrNoDecoder{Type: reflect.TypeOf("")}, }, { "ReadElement Error", make(map[string]interface{}), &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{Err: errors.New("re error"), ErrAfter: bsonrwtest.ReadElement}, bsonrwtest.ReadElement, errors.New("re error"), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "MapDecodeValue", Kinds: []reflect.Kind{reflect.Map}}, }, { "wrong BSON type", map[string]interface{}{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, errors.New("cannot decode string into a map[string]interface {}"), }, { "decode null", (map[string]interface{})(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", (map[string]interface{})(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "ArrayDecodeValue", ValueDecoderFunc(dvd.ArrayDecodeValue), []subtest{ { "wrong kind", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "ArrayDecodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: reflect.ValueOf(wrong)}, }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "ArrayDecodeValue", Kinds: []reflect.Kind{reflect.Array}}, }, { "Not Type Array", [1]interface{}{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, errors.New("cannot decode string into an array"), }, { "ReadArray Error", [1]interface{}{}, nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("ra error"), ErrAfter: bsonrwtest.ReadArray, BSONType: bsontype.Array}, bsonrwtest.ReadArray, errors.New("ra error"), }, { "Lookup Error", [1]string{}, &DecodeContext{Registry: NewRegistryBuilder().Build()}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array}, bsonrwtest.ReadArray, ErrNoDecoder{Type: reflect.TypeOf("")}, }, { "ReadValue Error", [1]string{}, &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{Err: errors.New("rv error"), ErrAfter: bsonrwtest.ReadValue, BSONType: bsontype.Array}, bsonrwtest.ReadValue, errors.New("rv error"), }, { "DecodeValue Error", [1]string{}, &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array}, bsonrwtest.ReadValue, &DecodeError{keys: []string{"0"}, wrapped: errors.New("cannot decode array into a string type")}, }, { "Document but not D", [1]string{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Type(0)}, bsonrwtest.Nothing, errors.New("cannot decode document into [1]string"), }, { "EmbeddedDocument but not D", [1]string{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.EmbeddedDocument}, bsonrwtest.Nothing, errors.New("cannot decode document into [1]string"), }, { "decode null", [1]string{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", [1]string{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "defaultSliceCodec.DecodeValue", defaultSliceCodec, []subtest{ { "wrong kind", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "SliceDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: reflect.ValueOf(wrong)}, }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "SliceDecodeValue", Kinds: []reflect.Kind{reflect.Slice}}, }, { "Not Type Array", []interface{}{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32}, bsonrwtest.Nothing, errors.New("cannot decode 32-bit integer into a slice"), }, { "ReadArray Error", []interface{}{}, nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("ra error"), ErrAfter: bsonrwtest.ReadArray, BSONType: bsontype.Array}, bsonrwtest.ReadArray, errors.New("ra error"), }, { "Lookup Error", []string{}, &DecodeContext{Registry: NewRegistryBuilder().Build()}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array}, bsonrwtest.ReadArray, ErrNoDecoder{Type: reflect.TypeOf("")}, }, { "ReadValue Error", []string{}, &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{Err: errors.New("rv error"), ErrAfter: bsonrwtest.ReadValue, BSONType: bsontype.Array}, bsonrwtest.ReadValue, errors.New("rv error"), }, { "DecodeValue Error", []string{}, &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array}, bsonrwtest.ReadValue, &DecodeError{keys: []string{"0"}, wrapped: errors.New("cannot decode array into a string type")}, }, { "Document but not D", []string{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Type(0)}, bsonrwtest.Nothing, errors.New("cannot decode document into []string"), }, { "EmbeddedDocument but not D", []string{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.EmbeddedDocument}, bsonrwtest.Nothing, errors.New("cannot decode document into []string"), }, { "decode null", ([]string)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", ([]string)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "ObjectIDDecodeValue", ValueDecoderFunc(dvd.ObjectIDDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.ObjectID}, bsonrwtest.Nothing, ValueDecoderError{Name: "ObjectIDDecodeValue", Types: []reflect.Type{tOID}, Received: reflect.ValueOf(wrong)}, }, { "type not objectID", primitive.ObjectID{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into an ObjectID", bsontype.Int32), }, { "ReadObjectID Error", primitive.ObjectID{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.ObjectID, Err: errors.New("roid error"), ErrAfter: bsonrwtest.ReadObjectID}, bsonrwtest.ReadObjectID, errors.New("roid error"), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.ObjectID, Return: primitive.ObjectID{}}, bsonrwtest.Nothing, ValueDecoderError{Name: "ObjectIDDecodeValue", Types: []reflect.Type{tOID}}, }, { "success", primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.ObjectID, Return: primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C}, }, bsonrwtest.ReadObjectID, nil, }, { "success/string", primitive.ObjectID{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.String, Return: "0123456789ab", }, bsonrwtest.ReadString, nil, }, { "success/string-hex", primitive.ObjectID{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.String, Return: "303132333435363738396162", }, bsonrwtest.ReadString, nil, }, { "decode null", primitive.ObjectID{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.ObjectID{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "Decimal128DecodeValue", ValueDecoderFunc(dvd.Decimal128DecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Decimal128}, bsonrwtest.Nothing, ValueDecoderError{Name: "Decimal128DecodeValue", Types: []reflect.Type{tDecimal}, Received: reflect.ValueOf(wrong)}, }, { "type not decimal128", primitive.Decimal128{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a primitive.Decimal128", bsontype.String), }, { "ReadDecimal128 Error", primitive.Decimal128{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Decimal128, Err: errors.New("rd128 error"), ErrAfter: bsonrwtest.ReadDecimal128}, bsonrwtest.ReadDecimal128, errors.New("rd128 error"), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Decimal128, Return: d128}, bsonrwtest.Nothing, ValueDecoderError{Name: "Decimal128DecodeValue", Types: []reflect.Type{tDecimal}}, }, { "success", d128, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Decimal128, Return: d128}, bsonrwtest.ReadDecimal128, nil, }, { "decode null", primitive.Decimal128{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.Decimal128{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "JSONNumberDecodeValue", ValueDecoderFunc(dvd.JSONNumberDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.ObjectID}, bsonrwtest.Nothing, ValueDecoderError{Name: "JSONNumberDecodeValue", Types: []reflect.Type{tJSONNumber}, Received: reflect.ValueOf(wrong)}, }, { "type not double/int32/int64", json.Number(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a json.Number", bsontype.String), }, { "ReadDouble Error", json.Number(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Err: errors.New("rd error"), ErrAfter: bsonrwtest.ReadDouble}, bsonrwtest.ReadDouble, errors.New("rd error"), }, { "ReadInt32 Error", json.Number(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Err: errors.New("ri32 error"), ErrAfter: bsonrwtest.ReadInt32}, bsonrwtest.ReadInt32, errors.New("ri32 error"), }, { "ReadInt64 Error", json.Number(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Err: errors.New("ri64 error"), ErrAfter: bsonrwtest.ReadInt64}, bsonrwtest.ReadInt64, errors.New("ri64 error"), }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.ObjectID, Return: primitive.ObjectID{}}, bsonrwtest.Nothing, ValueDecoderError{Name: "JSONNumberDecodeValue", Types: []reflect.Type{tJSONNumber}}, }, { "success/double", json.Number("3.14159"), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14159)}, bsonrwtest.ReadDouble, nil, }, { "success/int32", json.Number("12345"), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32, Return: int32(12345)}, bsonrwtest.ReadInt32, nil, }, { "success/int64", json.Number("1234567890"), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int64, Return: int64(1234567890)}, bsonrwtest.ReadInt64, nil, }, { "decode null", json.Number(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", json.Number(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "URLDecodeValue", ValueDecoderFunc(dvd.URLDecodeValue), []subtest{ { "wrong type", url.URL{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a *url.URL", bsontype.Int32), }, { "type not *url.URL", int64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "http://example.com"}, bsonrwtest.Nothing, ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}, Received: reflect.ValueOf(int64(0))}, }, { "ReadString error", url.URL{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Err: errors.New("rs error"), ErrAfter: bsonrwtest.ReadString}, bsonrwtest.ReadString, errors.New("rs error"), }, { "url.Parse error", url.URL{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "not-valid-%%%%://"}, bsonrwtest.ReadString, &url.Error{ Op: "parse", URL: "not-valid-%%%%://", Err: errors.New("first path segment in URL cannot contain colon"), }, }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "http://example.com"}, bsonrwtest.Nothing, ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}}, }, { "url.URL", url.URL{Scheme: "http", Host: "example.com"}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "http://example.com"}, bsonrwtest.ReadString, nil, }, { "decode null", url.URL{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", url.URL{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "defaultByteSliceCodec.DecodeValue", defaultByteSliceCodec, []subtest{ { "wrong type", []byte{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a []byte", bsontype.Int32), }, { "type not []byte", int64(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Binary, Return: bsoncore.Value{Type: bsontype.Binary}}, bsonrwtest.Nothing, ValueDecoderError{Name: "ByteSliceDecodeValue", Types: []reflect.Type{tByteSlice}, Received: reflect.ValueOf(int64(0))}, }, { "ReadBinary error", []byte{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Binary, Err: errors.New("rb error"), ErrAfter: bsonrwtest.ReadBinary}, bsonrwtest.ReadBinary, errors.New("rb error"), }, { "incorrect subtype", []byte{}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.Binary, Return: bsoncore.Value{ Type: bsontype.Binary, Data: bsoncore.AppendBinary(nil, 0xFF, []byte{0x01, 0x02, 0x03}), }, }, bsonrwtest.ReadBinary, decodeBinaryError{subtype: byte(0xFF), typeName: "[]byte"}, }, { "can set false", cansettest, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Binary, Return: bsoncore.AppendBinary(nil, 0x00, []byte{0x01, 0x02, 0x03})}, bsonrwtest.Nothing, ValueDecoderError{Name: "ByteSliceDecodeValue", Types: []reflect.Type{tByteSlice}}, }, { "decode null", ([]byte)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", ([]byte)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "defaultStringCodec.DecodeValue", defaultStringCodec, []subtest{ { "symbol", "var hello = 'world';", nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Symbol, Return: "var hello = 'world';"}, bsonrwtest.ReadSymbol, nil, }, { "decode null", "", nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", "", nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "ValueUnmarshalerDecodeValue", ValueDecoderFunc(dvd.ValueUnmarshalerDecodeValue), []subtest{ { "wrong type", wrong, nil, nil, bsonrwtest.Nothing, ValueDecoderError{ Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: reflect.ValueOf(wrong), }, }, { "copy error", &testValueUnmarshaler{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Err: errors.New("copy error"), ErrAfter: bsonrwtest.ReadString}, bsonrwtest.ReadString, errors.New("copy error"), }, { "ValueUnmarshaler", &testValueUnmarshaler{t: bsontype.String, val: bsoncore.AppendString(nil, "hello, world")}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "hello, world"}, bsonrwtest.ReadString, nil, }, }, }, { "UnmarshalerDecodeValue", ValueDecoderFunc(dvd.UnmarshalerDecodeValue), []subtest{ { "wrong type", wrong, nil, nil, bsonrwtest.Nothing, ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: reflect.ValueOf(wrong)}, }, { "copy error", &testUnmarshaler{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Err: errors.New("copy error"), ErrAfter: bsonrwtest.ReadString}, bsonrwtest.ReadString, errors.New("copy error"), }, { // Only the pointer form of testUnmarshaler implements Unmarshaler "value does not implement Unmarshaler", testUnmarshaler{Val: bsoncore.AppendDouble(nil, 3.14159)}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14159)}, bsonrwtest.ReadDouble, nil, }, { "Unmarshaler", &testUnmarshaler{Val: bsoncore.AppendDouble(nil, 3.14159)}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double, Return: float64(3.14159)}, bsonrwtest.ReadDouble, nil, }, }, }, { "PointerCodec.DecodeValue", NewPointerCodec(), []subtest{ { "not valid", nil, nil, nil, bsonrwtest.Nothing, ValueDecoderError{Name: "PointerCodec.DecodeValue", Kinds: []reflect.Kind{reflect.Ptr}, Received: reflect.Value{}}, }, { "can set", cansettest, nil, nil, bsonrwtest.Nothing, ValueDecoderError{Name: "PointerCodec.DecodeValue", Kinds: []reflect.Kind{reflect.Ptr}}, }, { "No Decoder", &wrong, &DecodeContext{Registry: buildDefaultRegistry()}, nil, bsonrwtest.Nothing, ErrNoDecoder{Type: reflect.TypeOf(wrong)}, }, { "decode null", (*mystruct)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", (*mystruct)(nil), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "BinaryDecodeValue", ValueDecoderFunc(dvd.BinaryDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{Name: "BinaryDecodeValue", Types: []reflect.Type{tBinary}, Received: reflect.ValueOf(wrong)}, }, { "type not binary", primitive.Binary{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a Binary", bsontype.String), }, { "ReadBinary Error", primitive.Binary{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Binary, Err: errors.New("rb error"), ErrAfter: bsonrwtest.ReadBinary}, bsonrwtest.ReadBinary, errors.New("rb error"), }, { "Binary/success", primitive.Binary{Data: []byte{0x01, 0x02, 0x03}, Subtype: 0xFF}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.Binary, Return: bsoncore.Value{ Type: bsontype.Binary, Data: bsoncore.AppendBinary(nil, 0xFF, []byte{0x01, 0x02, 0x03}), }, }, bsonrwtest.ReadBinary, nil, }, { "decode null", primitive.Binary{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.Binary{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "UndefinedDecodeValue", ValueDecoderFunc(dvd.UndefinedDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.Nothing, ValueDecoderError{Name: "UndefinedDecodeValue", Types: []reflect.Type{tUndefined}, Received: reflect.ValueOf(wrong)}, }, { "type not undefined", primitive.Undefined{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into an Undefined", bsontype.String), }, { "ReadUndefined Error", primitive.Undefined{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined, Err: errors.New("ru error"), ErrAfter: bsonrwtest.ReadUndefined}, bsonrwtest.ReadUndefined, errors.New("ru error"), }, { "ReadUndefined/success", primitive.Undefined{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, { "decode null", primitive.Undefined{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, }, }, { "DateTimeDecodeValue", ValueDecoderFunc(dvd.DateTimeDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime}, bsonrwtest.Nothing, ValueDecoderError{Name: "DateTimeDecodeValue", Types: []reflect.Type{tDateTime}, Received: reflect.ValueOf(wrong)}, }, { "type not datetime", primitive.DateTime(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a DateTime", bsontype.String), }, { "ReadDateTime Error", primitive.DateTime(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Err: errors.New("rdt error"), ErrAfter: bsonrwtest.ReadDateTime}, bsonrwtest.ReadDateTime, errors.New("rdt error"), }, { "success", primitive.DateTime(1234567890), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: int64(1234567890)}, bsonrwtest.ReadDateTime, nil, }, { "decode null", primitive.DateTime(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.DateTime(0), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "NullDecodeValue", ValueDecoderFunc(dvd.NullDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.Nothing, ValueDecoderError{Name: "NullDecodeValue", Types: []reflect.Type{tNull}, Received: reflect.ValueOf(wrong)}, }, { "type not null", primitive.Null{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a Null", bsontype.String), }, { "ReadNull Error", primitive.Null{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null, Err: errors.New("rn error"), ErrAfter: bsonrwtest.ReadNull}, bsonrwtest.ReadNull, errors.New("rn error"), }, { "success", primitive.Null{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, }, }, { "RegexDecodeValue", ValueDecoderFunc(dvd.RegexDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Regex}, bsonrwtest.Nothing, ValueDecoderError{Name: "RegexDecodeValue", Types: []reflect.Type{tRegex}, Received: reflect.ValueOf(wrong)}, }, { "type not regex", primitive.Regex{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a Regex", bsontype.String), }, { "ReadRegex Error", primitive.Regex{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Regex, Err: errors.New("rr error"), ErrAfter: bsonrwtest.ReadRegex}, bsonrwtest.ReadRegex, errors.New("rr error"), }, { "success", primitive.Regex{Pattern: "foo", Options: "bar"}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.Regex, Return: bsoncore.Value{ Type: bsontype.Regex, Data: bsoncore.AppendRegex(nil, "foo", "bar"), }, }, bsonrwtest.ReadRegex, nil, }, { "decode null", primitive.Regex{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.Regex{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "DBPointerDecodeValue", ValueDecoderFunc(dvd.DBPointerDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DBPointer}, bsonrwtest.Nothing, ValueDecoderError{Name: "DBPointerDecodeValue", Types: []reflect.Type{tDBPointer}, Received: reflect.ValueOf(wrong)}, }, { "type not dbpointer", primitive.DBPointer{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a DBPointer", bsontype.String), }, { "ReadDBPointer Error", primitive.DBPointer{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DBPointer, Err: errors.New("rdbp error"), ErrAfter: bsonrwtest.ReadDBPointer}, bsonrwtest.ReadDBPointer, errors.New("rdbp error"), }, { "success", primitive.DBPointer{ DB: "foobar", Pointer: primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C}, }, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.DBPointer, Return: bsoncore.Value{ Type: bsontype.DBPointer, Data: bsoncore.AppendDBPointer( nil, "foobar", primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C}, ), }, }, bsonrwtest.ReadDBPointer, nil, }, { "decode null", primitive.DBPointer{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.DBPointer{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "TimestampDecodeValue", ValueDecoderFunc(dvd.TimestampDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Timestamp}, bsonrwtest.Nothing, ValueDecoderError{Name: "TimestampDecodeValue", Types: []reflect.Type{tTimestamp}, Received: reflect.ValueOf(wrong)}, }, { "type not timestamp", primitive.Timestamp{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a Timestamp", bsontype.String), }, { "ReadTimestamp Error", primitive.Timestamp{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Timestamp, Err: errors.New("rt error"), ErrAfter: bsonrwtest.ReadTimestamp}, bsonrwtest.ReadTimestamp, errors.New("rt error"), }, { "success", primitive.Timestamp{T: 12345, I: 67890}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.Timestamp, Return: bsoncore.Value{ Type: bsontype.Timestamp, Data: bsoncore.AppendTimestamp(nil, 12345, 67890), }, }, bsonrwtest.ReadTimestamp, nil, }, { "decode null", primitive.Timestamp{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.Timestamp{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "MinKeyDecodeValue", ValueDecoderFunc(dvd.MinKeyDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.MinKey}, bsonrwtest.Nothing, ValueDecoderError{Name: "MinKeyDecodeValue", Types: []reflect.Type{tMinKey}, Received: reflect.ValueOf(wrong)}, }, { "type not null", primitive.MinKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a MinKey", bsontype.String), }, { "ReadMinKey Error", primitive.MinKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.MinKey, Err: errors.New("rn error"), ErrAfter: bsonrwtest.ReadMinKey}, bsonrwtest.ReadMinKey, errors.New("rn error"), }, { "success", primitive.MinKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.MinKey}, bsonrwtest.ReadMinKey, nil, }, { "decode null", primitive.MinKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.MinKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "MaxKeyDecodeValue", ValueDecoderFunc(dvd.MaxKeyDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.MaxKey}, bsonrwtest.Nothing, ValueDecoderError{Name: "MaxKeyDecodeValue", Types: []reflect.Type{tMaxKey}, Received: reflect.ValueOf(wrong)}, }, { "type not null", primitive.MaxKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a MaxKey", bsontype.String), }, { "ReadMaxKey Error", primitive.MaxKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.MaxKey, Err: errors.New("rn error"), ErrAfter: bsonrwtest.ReadMaxKey}, bsonrwtest.ReadMaxKey, errors.New("rn error"), }, { "success", primitive.MaxKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.MaxKey}, bsonrwtest.ReadMaxKey, nil, }, { "decode null", primitive.MaxKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.MaxKey{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "JavaScriptDecodeValue", ValueDecoderFunc(dvd.JavaScriptDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.JavaScript, Return: ""}, bsonrwtest.Nothing, ValueDecoderError{Name: "JavaScriptDecodeValue", Types: []reflect.Type{tJavaScript}, Received: reflect.ValueOf(wrong)}, }, { "type not Javascript", primitive.JavaScript(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a primitive.JavaScript", bsontype.String), }, { "ReadJavascript Error", primitive.JavaScript(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.JavaScript, Err: errors.New("rjs error"), ErrAfter: bsonrwtest.ReadJavascript}, bsonrwtest.ReadJavascript, errors.New("rjs error"), }, { "JavaScript/success", primitive.JavaScript("var hello = 'world';"), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.JavaScript, Return: "var hello = 'world';"}, bsonrwtest.ReadJavascript, nil, }, { "decode null", primitive.JavaScript(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.JavaScript(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "SymbolDecodeValue", ValueDecoderFunc(dvd.SymbolDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Symbol, Return: ""}, bsonrwtest.Nothing, ValueDecoderError{Name: "SymbolDecodeValue", Types: []reflect.Type{tSymbol}, Received: reflect.ValueOf(wrong)}, }, { "type not Symbol", primitive.Symbol(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Int32}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a primitive.Symbol", bsontype.Int32), }, { "ReadSymbol Error", primitive.Symbol(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Symbol, Err: errors.New("rjs error"), ErrAfter: bsonrwtest.ReadSymbol}, bsonrwtest.ReadSymbol, errors.New("rjs error"), }, { "Symbol/success", primitive.Symbol("var hello = 'world';"), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Symbol, Return: "var hello = 'world';"}, bsonrwtest.ReadSymbol, nil, }, { "decode null", primitive.Symbol(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.Symbol(""), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "CoreDocumentDecodeValue", ValueDecoderFunc(dvd.CoreDocumentDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{ Name: "CoreDocumentDecodeValue", Types: []reflect.Type{tCoreDocument}, Received: reflect.ValueOf(wrong), }, }, { "*bsoncore.Document is nil", (*bsoncore.Document)(nil), nil, nil, bsonrwtest.Nothing, ValueDecoderError{ Name: "CoreDocumentDecodeValue", Types: []reflect.Type{tCoreDocument}, Received: reflect.ValueOf((*bsoncore.Document)(nil)), }, }, { "Copy error", bsoncore.Document{}, nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("copy error"), ErrAfter: bsonrwtest.ReadDocument}, bsonrwtest.ReadDocument, errors.New("copy error"), }, }, }, { "StructCodec.DecodeValue", defaultTestStructCodec, []subtest{ { "Not struct", reflect.New(reflect.TypeOf(struct{ Foo string }{})).Elem().Interface(), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, errors.New("cannot decode string into a struct { Foo string }"), }, { "decode null", reflect.New(reflect.TypeOf(struct{ Foo string }{})).Elem().Interface(), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", reflect.New(reflect.TypeOf(struct{ Foo string }{})).Elem().Interface(), nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "CodeWithScopeDecodeValue", ValueDecoderFunc(dvd.CodeWithScopeDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.CodeWithScope}, bsonrwtest.Nothing, ValueDecoderError{ Name: "CodeWithScopeDecodeValue", Types: []reflect.Type{tCodeWithScope}, Received: reflect.ValueOf(wrong), }, }, { "type not codewithscope", primitive.CodeWithScope{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String}, bsonrwtest.Nothing, fmt.Errorf("cannot decode %v into a primitive.CodeWithScope", bsontype.String), }, { "ReadCodeWithScope Error", primitive.CodeWithScope{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.CodeWithScope, Err: errors.New("rcws error"), ErrAfter: bsonrwtest.ReadCodeWithScope}, bsonrwtest.ReadCodeWithScope, errors.New("rcws error"), }, { "decodeDocument Error", primitive.CodeWithScope{ Code: "var hello = 'world';", Scope: primitive.D{{"foo", nil}}, }, &DecodeContext{Registry: buildDefaultRegistry()}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.CodeWithScope, Err: errors.New("dd error"), ErrAfter: bsonrwtest.ReadElement}, bsonrwtest.ReadElement, errors.New("dd error"), }, { "decode null", primitive.CodeWithScope{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Null}, bsonrwtest.ReadNull, nil, }, { "decode undefined", primitive.CodeWithScope{}, nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Undefined}, bsonrwtest.ReadUndefined, nil, }, }, }, { "CoreArrayDecodeValue", defaultArrayCodec, []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, ValueDecoderError{ Name: "CoreArrayDecodeValue", Types: []reflect.Type{tCoreArray}, Received: reflect.ValueOf(wrong), }, }, { "*bsoncore.Array is nil", (*bsoncore.Array)(nil), nil, nil, bsonrwtest.Nothing, ValueDecoderError{ Name: "CoreArrayDecodeValue", Types: []reflect.Type{tCoreArray}, Received: reflect.ValueOf((*bsoncore.Array)(nil)), }, }, }, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { for _, rc := range tc.subtests { t.Run(rc.name, func(t *testing.T) { var dc DecodeContext if rc.dctx != nil { dc = *rc.dctx } llvrw := new(bsonrwtest.ValueReaderWriter) if rc.llvrw != nil { llvrw = rc.llvrw } llvrw.T = t // var got interface{} if rc.val == cansetreflectiontest { // We're doing a CanSet reflection test err := tc.vd.DecodeValue(dc, llvrw, reflect.Value{}) if !compareErrors(err, rc.err) { t.Errorf("Errors do not match. got %v; want %v", err, rc.err) } val := reflect.New(reflect.TypeOf(rc.val)).Elem() err = tc.vd.DecodeValue(dc, llvrw, val) if !compareErrors(err, rc.err) { t.Errorf("Errors do not match. got %v; want %v", err, rc.err) } return } if rc.val == cansettest { // We're doing an IsValid and CanSet test var wanterr ValueDecoderError if !errors.As(rc.err, &wanterr) { t.Fatalf("Error must be a DecodeValueError, but got a %T", rc.err) } err := tc.vd.DecodeValue(dc, llvrw, reflect.Value{}) wanterr.Received = reflect.ValueOf(nil) if !compareErrors(err, wanterr) { t.Errorf("Errors do not match. got %v; want %v", err, wanterr) } err = tc.vd.DecodeValue(dc, llvrw, reflect.ValueOf(int(12345))) wanterr.Received = reflect.ValueOf(int(12345)) if !compareErrors(err, wanterr) { t.Errorf("Errors do not match. got %v; want %v", err, wanterr) } return } var val reflect.Value if rtype := reflect.TypeOf(rc.val); rtype != nil { val = reflect.New(rtype).Elem() } want := rc.val defer func() { if err := recover(); err != nil { fmt.Println(t.Name()) panic(err) } }() err := tc.vd.DecodeValue(dc, llvrw, val) if !compareErrors(err, rc.err) { t.Errorf("Errors do not match. got %v; want %v", err, rc.err) } invoked := llvrw.Invoked if !cmp.Equal(invoked, rc.invoke) { t.Errorf("Incorrect method invoked. got %v; want %v", invoked, rc.invoke) } var got interface{} if val.IsValid() && val.CanInterface() { got = val.Interface() } if rc.err == nil && !cmp.Equal(got, want, cmp.Comparer(compareDecimal128)) { t.Errorf("Values do not match. got (%T)%v; want (%T)%v", got, got, want, want) } }) } }) } t.Run("CodeWithScopeCodec/DecodeValue/success", func(t *testing.T) { dc := DecodeContext{Registry: buildDefaultRegistry()} b := bsoncore.BuildDocument(nil, bsoncore.AppendCodeWithScopeElement( nil, "foo", "var hello = 'world';", buildDocument(bsoncore.AppendNullElement(nil, "bar")), ), ) dvr := bsonrw.NewBSONDocumentReader(b) dr, err := dvr.ReadDocument() noerr(t, err) _, vr, err := dr.ReadElement() noerr(t, err) want := primitive.CodeWithScope{ Code: "var hello = 'world';", Scope: primitive.D{{"bar", nil}}, } val := reflect.New(tCodeWithScope).Elem() err = dvd.CodeWithScopeDecodeValue(dc, vr, val) noerr(t, err) got := val.Interface().(primitive.CodeWithScope) if got.Code != want.Code && !cmp.Equal(got.Scope, want.Scope) { t.Errorf("CodeWithScopes do not match. got %v; want %v", got, want) } }) t.Run("ValueUnmarshalerDecodeValue/UnmarshalBSONValue error", func(t *testing.T) { var dc DecodeContext llvrw := &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("hello, world!")} llvrw.T = t want := errors.New("ubsonv error") valUnmarshaler := &testValueUnmarshaler{err: want} got := dvd.ValueUnmarshalerDecodeValue(dc, llvrw, reflect.ValueOf(valUnmarshaler)) if !compareErrors(got, want) { t.Errorf("Errors do not match. got %v; want %v", got, want) } }) t.Run("ValueUnmarshalerDecodeValue/Unaddressable value", func(t *testing.T) { var dc DecodeContext llvrw := &bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("hello, world!")} llvrw.T = t val := reflect.ValueOf(testValueUnmarshaler{}) want := ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val} got := dvd.ValueUnmarshalerDecodeValue(dc, llvrw, val) if !compareErrors(got, want) { t.Errorf("Errors do not match. got %v; want %v", got, want) } }) t.Run("SliceCodec/DecodeValue/can't set slice", func(t *testing.T) { var val []string want := ValueDecoderError{Name: "SliceDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: reflect.ValueOf(val)} got := dvd.SliceDecodeValue(DecodeContext{}, nil, reflect.ValueOf(val)) if !compareErrors(got, want) { t.Errorf("Errors do not match. got %v; want %v", got, want) } }) t.Run("SliceCodec/DecodeValue/too many elements", func(t *testing.T) { idx, doc := bsoncore.AppendDocumentStart(nil) aidx, doc := bsoncore.AppendArrayElementStart(doc, "foo") doc = bsoncore.AppendStringElement(doc, "0", "foo") doc = bsoncore.AppendStringElement(doc, "1", "bar") doc, err := bsoncore.AppendArrayEnd(doc, aidx) noerr(t, err) doc, err = bsoncore.AppendDocumentEnd(doc, idx) noerr(t, err) dvr := bsonrw.NewBSONDocumentReader(doc) noerr(t, err) dr, err := dvr.ReadDocument() noerr(t, err) _, vr, err := dr.ReadElement() noerr(t, err) var val [1]string want := fmt.Errorf("more elements returned in array than can fit inside %T, got 2 elements", val) dc := DecodeContext{Registry: buildDefaultRegistry()} got := dvd.ArrayDecodeValue(dc, vr, reflect.ValueOf(val)) if !compareErrors(got, want) { t.Errorf("Errors do not match. got %v; want %v", got, want) } }) t.Run("success path", func(t *testing.T) { oid := primitive.NewObjectID() oids := []primitive.ObjectID{primitive.NewObjectID(), primitive.NewObjectID(), primitive.NewObjectID()} var str = new(string) *str = "bar" now := time.Now().Truncate(time.Millisecond).UTC() murl, err := url.Parse("https://mongodb.com/random-url?hello=world") if err != nil { t.Errorf("Error parsing URL: %v", err) t.FailNow() } decimal128, err := primitive.ParseDecimal128("1.5e10") if err != nil { t.Errorf("Error parsing decimal128: %v", err) t.FailNow() } testCases := []struct { name string value interface{} b []byte err error }{ { "map[string]int", map[string]int32{"foo": 1}, []byte{ 0x0E, 0x00, 0x00, 0x00, 0x10, 'f', 'o', 'o', 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, }, nil, }, { "map[string]primitive.ObjectID", map[string]primitive.ObjectID{"foo": oid}, func() []byte { idx, doc := bsoncore.AppendDocumentStart(nil) doc = bsoncore.AppendObjectIDElement(doc, "foo", oid) doc, _ = bsoncore.AppendDocumentEnd(doc, idx) return doc }(), nil, }, { "map[string][]int32", map[string][]int32{"Z": {1, 2, 3}}, buildDocumentArray(func(doc []byte) []byte { doc = bsoncore.AppendInt32Element(doc, "0", 1) doc = bsoncore.AppendInt32Element(doc, "1", 2) return bsoncore.AppendInt32Element(doc, "2", 3) }), nil, }, { "map[string][]primitive.ObjectID", map[string][]primitive.ObjectID{"Z": oids}, buildDocumentArray(func(doc []byte) []byte { doc = bsoncore.AppendObjectIDElement(doc, "0", oids[0]) doc = bsoncore.AppendObjectIDElement(doc, "1", oids[1]) return bsoncore.AppendObjectIDElement(doc, "2", oids[2]) }), nil, }, { "map[string][]json.Number(int64)", map[string][]json.Number{"Z": {json.Number("5"), json.Number("10")}}, buildDocumentArray(func(doc []byte) []byte { doc = bsoncore.AppendInt64Element(doc, "0", 5) return bsoncore.AppendInt64Element(doc, "1", 10) }), nil, }, { "map[string][]json.Number(float64)", map[string][]json.Number{"Z": {json.Number("5"), json.Number("10.1")}}, buildDocumentArray(func(doc []byte) []byte { doc = bsoncore.AppendInt64Element(doc, "0", 5) return bsoncore.AppendDoubleElement(doc, "1", 10.1) }), nil, }, { "map[string][]*url.URL", map[string][]*url.URL{"Z": {murl}}, buildDocumentArray(func(doc []byte) []byte { return bsoncore.AppendStringElement(doc, "0", murl.String()) }), nil, }, { "map[string][]primitive.Decimal128", map[string][]primitive.Decimal128{"Z": {decimal128}}, buildDocumentArray(func(doc []byte) []byte { return bsoncore.AppendDecimal128Element(doc, "0", decimal128) }), nil, }, { "map[mystring]interface{}", map[mystring]interface{}{"pi": 3.14159}, buildDocument(bsoncore.AppendDoubleElement(nil, "pi", 3.14159)), nil, }, { "-", struct { A string `bson:"-"` }{ A: "", }, []byte{0x05, 0x00, 0x00, 0x00, 0x00}, nil, }, { "omitempty", struct { A string `bson:",omitempty"` }{ A: "", }, []byte{0x05, 0x00, 0x00, 0x00, 0x00}, nil, }, { "omitempty, empty time", struct { A time.Time `bson:",omitempty"` }{ A: time.Time{}, }, []byte{0x05, 0x00, 0x00, 0x00, 0x00}, nil, }, { "no private fields", noPrivateFields{a: "should be empty"}, []byte{0x05, 0x00, 0x00, 0x00, 0x00}, nil, }, { "minsize", struct { A int64 `bson:",minsize"` }{ A: 12345, }, buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)), nil, }, { "inline", struct { Foo struct { A int64 `bson:",minsize"` } `bson:",inline"` }{ Foo: struct { A int64 `bson:",minsize"` }{ A: 12345, }, }, buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)), nil, }, { "inline struct pointer", struct { Foo *struct { A int64 `bson:",minsize"` } `bson:",inline"` Bar *struct { B int64 } `bson:",inline"` }{ Foo: &struct { A int64 `bson:",minsize"` }{ A: 12345, }, Bar: nil, }, buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)), nil, }, { "nested inline struct pointer", struct { Foo *struct { Bar *struct { A int64 `bson:",minsize"` } `bson:",inline"` } `bson:",inline"` }{ Foo: &struct { Bar *struct { A int64 `bson:",minsize"` } `bson:",inline"` }{ Bar: &struct { A int64 `bson:",minsize"` }{ A: 12345, }, }, }, buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)), nil, }, { "inline nil struct pointer", struct { Foo *struct { A int64 `bson:",minsize"` } `bson:",inline"` }{ Foo: nil, }, buildDocument([]byte{}), nil, }, { "inline overwrite", struct { Foo struct { A int32 B string } `bson:",inline"` A int64 }{ Foo: struct { A int32 B string }{ A: 0, B: "foo", }, A: 54321, }, buildDocument(func(doc []byte) []byte { doc = bsoncore.AppendStringElement(doc, "b", "foo") doc = bsoncore.AppendInt64Element(doc, "a", 54321) return doc }(nil)), nil, }, { "inline overwrite with nested structs", struct { Foo struct { A int32 } `bson:",inline"` Bar struct { A int32 } `bson:",inline"` A int64 }{ Foo: struct { A int32 }{}, Bar: struct { A int32 }{}, A: 54321, }, buildDocument(bsoncore.AppendInt64Element(nil, "a", 54321)), nil, }, { "inline map", struct { Foo map[string]string `bson:",inline"` }{ Foo: map[string]string{"foo": "bar"}, }, buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")), nil, }, { "alternate name bson:name", struct { A string `bson:"foo"` }{ A: "bar", }, buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")), nil, }, { "alternate name", struct { A string `bson:"foo"` }{ A: "bar", }, buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")), nil, }, { "inline, omitempty", struct { A string Foo zeroTest `bson:"omitempty,inline"` }{ A: "bar", Foo: zeroTest{true}, }, buildDocument(bsoncore.AppendStringElement(nil, "a", "bar")), nil, }, { "struct{}", struct { A bool B int32 C int64 D uint16 E uint64 F float64 G string H map[string]string I []byte K [2]string L struct { M string } Q primitive.ObjectID T []struct{} Y json.Number Z time.Time AA json.Number AB *url.URL AC primitive.Decimal128 AD *time.Time AE *testValueUnmarshaler AF *bool AG *bool AH *int32 AI *int64 AJ *primitive.ObjectID AK *primitive.ObjectID AL testValueUnmarshaler AM interface{} AN interface{} AO interface{} AP primitive.D AQ primitive.A AR [2]primitive.E AS []byte AT map[string]interface{} AU primitive.CodeWithScope AV primitive.M AW primitive.D AX map[string]interface{} AY []primitive.E AZ interface{} }{ A: true, B: 123, C: 456, D: 789, E: 101112, F: 3.14159, G: "Hello, world", H: map[string]string{"foo": "bar"}, I: []byte{0x01, 0x02, 0x03}, K: [2]string{"baz", "qux"}, L: struct { M string }{ M: "foobar", }, Q: oid, T: nil, Y: json.Number("5"), Z: now, AA: json.Number("10.1"), AB: murl, AC: decimal128, AD: &now, AE: &testValueUnmarshaler{t: bsontype.String, val: bsoncore.AppendString(nil, "hello, world!")}, AF: func(b bool) *bool { return &b }(true), AG: nil, AH: func(i32 int32) *int32 { return &i32 }(12345), AI: func(i64 int64) *int64 { return &i64 }(1234567890), AJ: &oid, AK: nil, AL: testValueUnmarshaler{t: bsontype.String, val: bsoncore.AppendString(nil, "hello, world!")}, AM: "hello, world", AN: int32(12345), AO: oid, AP: primitive.D{{"foo", "bar"}}, AQ: primitive.A{"foo", "bar"}, AR: [2]primitive.E{{"hello", "world"}, {"pi", 3.14159}}, AS: nil, AT: nil, AU: primitive.CodeWithScope{Code: "var hello = 'world';", Scope: primitive.D{{"pi", 3.14159}}}, AV: primitive.M{"foo": primitive.M{"bar": "baz"}}, AW: primitive.D{{"foo", primitive.D{{"bar", "baz"}}}}, AX: map[string]interface{}{"foo": map[string]interface{}{"bar": "baz"}}, AY: []primitive.E{{"foo", []primitive.E{{"bar", "baz"}}}}, AZ: primitive.D{{"foo", primitive.D{{"bar", "baz"}}}}, }, buildDocument(func(doc []byte) []byte { doc = bsoncore.AppendBooleanElement(doc, "a", true) doc = bsoncore.AppendInt32Element(doc, "b", 123) doc = bsoncore.AppendInt64Element(doc, "c", 456) doc = bsoncore.AppendInt32Element(doc, "d", 789) doc = bsoncore.AppendInt64Element(doc, "e", 101112) doc = bsoncore.AppendDoubleElement(doc, "f", 3.14159) doc = bsoncore.AppendStringElement(doc, "g", "Hello, world") doc = bsoncore.AppendDocumentElement(doc, "h", buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar"))) doc = bsoncore.AppendBinaryElement(doc, "i", 0x00, []byte{0x01, 0x02, 0x03}) doc = bsoncore.AppendArrayElement(doc, "k", buildArray(bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "baz"), "1", "qux")), ) doc = bsoncore.AppendDocumentElement(doc, "l", buildDocument(bsoncore.AppendStringElement(nil, "m", "foobar"))) doc = bsoncore.AppendObjectIDElement(doc, "q", oid) doc = bsoncore.AppendNullElement(doc, "t") doc = bsoncore.AppendInt64Element(doc, "y", 5) doc = bsoncore.AppendDateTimeElement(doc, "z", now.UnixNano()/int64(time.Millisecond)) doc = bsoncore.AppendDoubleElement(doc, "aa", 10.1) doc = bsoncore.AppendStringElement(doc, "ab", murl.String()) doc = bsoncore.AppendDecimal128Element(doc, "ac", decimal128) doc = bsoncore.AppendDateTimeElement(doc, "ad", now.UnixNano()/int64(time.Millisecond)) doc = bsoncore.AppendStringElement(doc, "ae", "hello, world!") doc = bsoncore.AppendBooleanElement(doc, "af", true) doc = bsoncore.AppendNullElement(doc, "ag") doc = bsoncore.AppendInt32Element(doc, "ah", 12345) doc = bsoncore.AppendInt32Element(doc, "ai", 1234567890) doc = bsoncore.AppendObjectIDElement(doc, "aj", oid) doc = bsoncore.AppendNullElement(doc, "ak") doc = bsoncore.AppendStringElement(doc, "al", "hello, world!") doc = bsoncore.AppendStringElement(doc, "am", "hello, world") doc = bsoncore.AppendInt32Element(doc, "an", 12345) doc = bsoncore.AppendObjectIDElement(doc, "ao", oid) doc = bsoncore.AppendDocumentElement(doc, "ap", buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar"))) doc = bsoncore.AppendArrayElement(doc, "aq", buildArray(bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "foo"), "1", "bar")), ) doc = bsoncore.AppendDocumentElement(doc, "ar", buildDocument(bsoncore.AppendDoubleElement(bsoncore.AppendStringElement(nil, "hello", "world"), "pi", 3.14159)), ) doc = bsoncore.AppendNullElement(doc, "as") doc = bsoncore.AppendNullElement(doc, "at") doc = bsoncore.AppendCodeWithScopeElement(doc, "au", "var hello = 'world';", buildDocument(bsoncore.AppendDoubleElement(nil, "pi", 3.14159)), ) for _, name := range [5]string{"av", "aw", "ax", "ay", "az"} { doc = bsoncore.AppendDocumentElement(doc, name, buildDocument( bsoncore.AppendDocumentElement(nil, "foo", buildDocument( bsoncore.AppendStringElement(nil, "bar", "baz"), )), )) } return doc }(nil)), nil, }, { "struct{[]interface{}}", struct { A []bool B []int32 C []int64 D []uint16 E []uint64 F []float64 G []string H []map[string]string I [][]byte K [1][2]string L []struct { M string } N [][]string R []primitive.ObjectID T []struct{} W []map[string]struct{} X []map[string]struct{} Y []map[string]struct{} Z []time.Time AA []json.Number AB []*url.URL AC []primitive.Decimal128 AD []*time.Time AE []*testValueUnmarshaler AF []*bool AG []*int32 AH []*int64 AI []*primitive.ObjectID AJ []primitive.D AK []primitive.A AL [][2]primitive.E }{ A: []bool{true}, B: []int32{123}, C: []int64{456}, D: []uint16{789}, E: []uint64{101112}, F: []float64{3.14159}, G: []string{"Hello, world"}, H: []map[string]string{{"foo": "bar"}}, I: [][]byte{{0x01, 0x02, 0x03}}, K: [1][2]string{{"baz", "qux"}}, L: []struct { M string }{ { M: "foobar", }, }, N: [][]string{{"foo", "bar"}}, R: oids, T: nil, W: nil, X: []map[string]struct{}{}, // Should be empty BSON Array Y: []map[string]struct{}{{}}, // Should be BSON array with one element, an empty BSON SubDocument Z: []time.Time{now, now}, AA: []json.Number{json.Number("5"), json.Number("10.1")}, AB: []*url.URL{murl}, AC: []primitive.Decimal128{decimal128}, AD: []*time.Time{&now, &now}, AE: []*testValueUnmarshaler{ {t: bsontype.String, val: bsoncore.AppendString(nil, "hello")}, {t: bsontype.String, val: bsoncore.AppendString(nil, "world")}, }, AF: []*bool{pbool(true), nil}, AG: []*int32{pi32(12345), nil}, AH: []*int64{pi64(1234567890), nil, pi64(9012345678)}, AI: []*primitive.ObjectID{&oid, nil}, AJ: []primitive.D{{{"foo", "bar"}}, nil}, AK: []primitive.A{{"foo", "bar"}, nil}, AL: [][2]primitive.E{{{"hello", "world"}, {"pi", 3.14159}}}, }, buildDocument(func(doc []byte) []byte { doc = appendArrayElement(doc, "a", bsoncore.AppendBooleanElement(nil, "0", true)) doc = appendArrayElement(doc, "b", bsoncore.AppendInt32Element(nil, "0", 123)) doc = appendArrayElement(doc, "c", bsoncore.AppendInt64Element(nil, "0", 456)) doc = appendArrayElement(doc, "d", bsoncore.AppendInt32Element(nil, "0", 789)) doc = appendArrayElement(doc, "e", bsoncore.AppendInt64Element(nil, "0", 101112)) doc = appendArrayElement(doc, "f", bsoncore.AppendDoubleElement(nil, "0", 3.14159)) doc = appendArrayElement(doc, "g", bsoncore.AppendStringElement(nil, "0", "Hello, world")) doc = appendArrayElement(doc, "h", bsoncore.BuildDocumentElement(nil, "0", bsoncore.AppendStringElement(nil, "foo", "bar"))) doc = appendArrayElement(doc, "i", bsoncore.AppendBinaryElement(nil, "0", 0x00, []byte{0x01, 0x02, 0x03})) doc = appendArrayElement(doc, "k", appendArrayElement(nil, "0", bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "baz"), "1", "qux")), ) doc = appendArrayElement(doc, "l", bsoncore.BuildDocumentElement(nil, "0", bsoncore.AppendStringElement(nil, "m", "foobar"))) doc = appendArrayElement(doc, "n", appendArrayElement(nil, "0", bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "foo"), "1", "bar")), ) doc = appendArrayElement(doc, "r", bsoncore.AppendObjectIDElement( bsoncore.AppendObjectIDElement( bsoncore.AppendObjectIDElement(nil, "0", oids[0]), "1", oids[1]), "2", oids[2]), ) doc = bsoncore.AppendNullElement(doc, "t") doc = bsoncore.AppendNullElement(doc, "w") doc = appendArrayElement(doc, "x", nil) doc = appendArrayElement(doc, "y", bsoncore.BuildDocumentElement(nil, "0", nil)) doc = appendArrayElement(doc, "z", bsoncore.AppendDateTimeElement( bsoncore.AppendDateTimeElement( nil, "0", now.UnixNano()/int64(time.Millisecond)), "1", now.UnixNano()/int64(time.Millisecond)), ) doc = appendArrayElement(doc, "aa", bsoncore.AppendDoubleElement(bsoncore.AppendInt64Element(nil, "0", 5), "1", 10.10)) doc = appendArrayElement(doc, "ab", bsoncore.AppendStringElement(nil, "0", murl.String())) doc = appendArrayElement(doc, "ac", bsoncore.AppendDecimal128Element(nil, "0", decimal128)) doc = appendArrayElement(doc, "ad", bsoncore.AppendDateTimeElement( bsoncore.AppendDateTimeElement(nil, "0", now.UnixNano()/int64(time.Millisecond)), "1", now.UnixNano()/int64(time.Millisecond)), ) doc = appendArrayElement(doc, "ae", bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "hello"), "1", "world"), ) doc = appendArrayElement(doc, "af", bsoncore.AppendNullElement(bsoncore.AppendBooleanElement(nil, "0", true), "1"), ) doc = appendArrayElement(doc, "ag", bsoncore.AppendNullElement(bsoncore.AppendInt32Element(nil, "0", 12345), "1"), ) doc = appendArrayElement(doc, "ah", bsoncore.AppendInt64Element( bsoncore.AppendNullElement(bsoncore.AppendInt64Element(nil, "0", 1234567890), "1"), "2", 9012345678, ), ) doc = appendArrayElement(doc, "ai", bsoncore.AppendNullElement(bsoncore.AppendObjectIDElement(nil, "0", oid), "1"), ) doc = appendArrayElement(doc, "aj", bsoncore.AppendNullElement( bsoncore.AppendDocumentElement(nil, "0", buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar"))), "1", ), ) doc = appendArrayElement(doc, "ak", bsoncore.AppendNullElement( appendArrayElement(nil, "0", bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "foo"), "1", "bar"), ), "1", ), ) doc = appendArrayElement(doc, "al", bsoncore.BuildDocumentElement(nil, "0", bsoncore.AppendDoubleElement(bsoncore.AppendStringElement(nil, "hello", "world"), "pi", 3.14159), ), ) return doc }(nil)), nil, }, } t.Run("Decode", func(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { vr := bsonrw.NewBSONDocumentReader(tc.b) reg := buildDefaultRegistry() vtype := reflect.TypeOf(tc.value) dec, err := reg.LookupDecoder(vtype) noerr(t, err) gotVal := reflect.New(reflect.TypeOf(tc.value)).Elem() err = dec.DecodeValue(DecodeContext{Registry: reg}, vr, gotVal) noerr(t, err) got := gotVal.Interface() want := tc.value if diff := cmp.Diff( got, want, cmp.Comparer(compareDecimal128), cmp.Comparer(compareNoPrivateFields), cmp.Comparer(compareZeroTest), cmp.Comparer(compareTime), ); diff != "" { t.Errorf("difference:\n%s", diff) t.Errorf("Values are not equal.\ngot: %#v\nwant:%#v", got, want) } }) } }) }) t.Run("error path", func(t *testing.T) { testCases := []struct { name string value interface{} b []byte err error }{ { "duplicate name struct", struct { A int64 B int64 `bson:"a"` }{ A: 0, B: 54321, }, buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)), fmt.Errorf("duplicated key a"), }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { vr := bsonrw.NewBSONDocumentReader(tc.b) reg := buildDefaultRegistry() vtype := reflect.TypeOf(tc.value) dec, err := reg.LookupDecoder(vtype) noerr(t, err) gotVal := reflect.New(reflect.TypeOf(tc.value)).Elem() err = dec.DecodeValue(DecodeContext{Registry: reg}, vr, gotVal) if err == nil || !strings.Contains(err.Error(), tc.err.Error()) { t.Errorf("Did not receive expected error. got %v; want %v", err, tc.err) } }) } }) t.Run("defaultEmptyInterfaceCodec.DecodeValue", func(t *testing.T) { t.Run("DecodeValue", func(t *testing.T) { testCases := []struct { name string val interface{} bsontype bsontype.Type }{ { "Double - float64", float64(3.14159), bsontype.Double, }, { "String - string", "foo bar baz", bsontype.String, }, { "Array - primitive.A", primitive.A{3.14159}, bsontype.Array, }, { "Binary - Binary", primitive.Binary{Subtype: 0xFF, Data: []byte{0x01, 0x02, 0x03}}, bsontype.Binary, }, { "Undefined - Undefined", primitive.Undefined{}, bsontype.Undefined, }, { "ObjectID - primitive.ObjectID", primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C}, bsontype.ObjectID, }, { "Boolean - bool", bool(true), bsontype.Boolean, }, { "DateTime - DateTime", primitive.DateTime(1234567890), bsontype.DateTime, }, { "Null - Null", nil, bsontype.Null, }, { "Regex - Regex", primitive.Regex{Pattern: "foo", Options: "bar"}, bsontype.Regex, }, { "DBPointer - DBPointer", primitive.DBPointer{ DB: "foobar", Pointer: primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C}, }, bsontype.DBPointer, }, { "JavaScript - JavaScript", primitive.JavaScript("var foo = 'bar';"), bsontype.JavaScript, }, { "Symbol - Symbol", primitive.Symbol("foobarbazlolz"), bsontype.Symbol, }, { "Int32 - int32", int32(123456), bsontype.Int32, }, { "Int64 - int64", int64(1234567890), bsontype.Int64, }, { "Timestamp - Timestamp", primitive.Timestamp{T: 12345, I: 67890}, bsontype.Timestamp, }, { "Decimal128 - decimal.Decimal128", primitive.NewDecimal128(12345, 67890), bsontype.Decimal128, }, { "MinKey - MinKey", primitive.MinKey{}, bsontype.MinKey, }, { "MaxKey - MaxKey", primitive.MaxKey{}, bsontype.MaxKey, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { llvr := &bsonrwtest.ValueReaderWriter{BSONType: tc.bsontype} t.Run("Type Map failure", func(t *testing.T) { if tc.bsontype == bsontype.Null { t.Skip() } val := reflect.New(tEmpty).Elem() dc := DecodeContext{Registry: NewRegistryBuilder().Build()} want := ErrNoTypeMapEntry{Type: tc.bsontype} got := defaultEmptyInterfaceCodec.DecodeValue(dc, llvr, val) if !compareErrors(got, want) { t.Errorf("Errors are not equal. got %v; want %v", got, want) } }) t.Run("Lookup failure", func(t *testing.T) { if tc.bsontype == bsontype.Null { t.Skip() } val := reflect.New(tEmpty).Elem() dc := DecodeContext{ Registry: NewRegistryBuilder(). RegisterTypeMapEntry(tc.bsontype, reflect.TypeOf(tc.val)). Build(), } want := ErrNoDecoder{Type: reflect.TypeOf(tc.val)} got := defaultEmptyInterfaceCodec.DecodeValue(dc, llvr, val) if !compareErrors(got, want) { t.Errorf("Errors are not equal. got %v; want %v", got, want) } }) t.Run("DecodeValue failure", func(t *testing.T) { if tc.bsontype == bsontype.Null { t.Skip() } want := errors.New("DecodeValue failure error") llc := &llCodec{t: t, err: want} dc := DecodeContext{ Registry: NewRegistryBuilder(). RegisterTypeDecoder(reflect.TypeOf(tc.val), llc). RegisterTypeMapEntry(tc.bsontype, reflect.TypeOf(tc.val)). Build(), } got := defaultEmptyInterfaceCodec.DecodeValue(dc, llvr, reflect.New(tEmpty).Elem()) if !compareErrors(got, want) { t.Errorf("Errors are not equal. got %v; want %v", got, want) } }) t.Run("Success", func(t *testing.T) { want := tc.val llc := &llCodec{t: t, decodeval: tc.val} dc := DecodeContext{ Registry: NewRegistryBuilder(). RegisterTypeDecoder(reflect.TypeOf(tc.val), llc). RegisterTypeMapEntry(tc.bsontype, reflect.TypeOf(tc.val)). Build(), } got := reflect.New(tEmpty).Elem() err := defaultEmptyInterfaceCodec.DecodeValue(dc, llvr, got) noerr(t, err) if !cmp.Equal(got.Interface(), want, cmp.Comparer(compareDecimal128)) { t.Errorf("Did not receive expected value. got %v; want %v", got.Interface(), want) } }) }) } }) t.Run("non-interface{}", func(t *testing.T) { val := uint64(1234567890) want := ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: reflect.ValueOf(val)} got := defaultEmptyInterfaceCodec.DecodeValue(DecodeContext{}, nil, reflect.ValueOf(val)) if !compareErrors(got, want) { t.Errorf("Errors are not equal. got %v; want %v", got, want) } }) t.Run("nil *interface{}", func(t *testing.T) { var val interface{} want := ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: reflect.ValueOf(val)} got := defaultEmptyInterfaceCodec.DecodeValue(DecodeContext{}, nil, reflect.ValueOf(val)) if !compareErrors(got, want) { t.Errorf("Errors are not equal. got %v; want %v", got, want) } }) t.Run("no type registered", func(t *testing.T) { llvr := &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Double} want := ErrNoTypeMapEntry{Type: bsontype.Double} val := reflect.New(tEmpty).Elem() got := defaultEmptyInterfaceCodec.DecodeValue(DecodeContext{Registry: NewRegistryBuilder().Build()}, llvr, val) if !compareErrors(got, want) { t.Errorf("Errors are not equal. got %v; want %v", got, want) } }) t.Run("top level document", func(t *testing.T) { data := bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159)) vr := bsonrw.NewBSONDocumentReader(data) want := primitive.D{{"pi", 3.14159}} var got interface{} val := reflect.ValueOf(&got).Elem() err := defaultEmptyInterfaceCodec.DecodeValue(DecodeContext{Registry: buildDefaultRegistry()}, vr, val) noerr(t, err) if !cmp.Equal(got, want) { t.Errorf("Did not get correct result. got %v; want %v", got, want) } }) t.Run("custom type map entry", func(t *testing.T) { // registering a custom type map entry for both bsontype.Type(0) anad bsontype.EmbeddedDocument should cause // both top-level and embedded documents to decode to registered type when unmarshalling to interface{} topLevelRb := NewRegistryBuilder() defaultValueEncoders.RegisterDefaultEncoders(topLevelRb) defaultValueDecoders.RegisterDefaultDecoders(topLevelRb) topLevelRb.RegisterTypeMapEntry(bsontype.Type(0), reflect.TypeOf(primitive.M{})) embeddedRb := NewRegistryBuilder() defaultValueEncoders.RegisterDefaultEncoders(embeddedRb) defaultValueDecoders.RegisterDefaultDecoders(embeddedRb) embeddedRb.RegisterTypeMapEntry(bsontype.Type(0), reflect.TypeOf(primitive.M{})) // create doc {"nested": {"foo": 1}} innerDoc := bsoncore.BuildDocument( nil, bsoncore.AppendInt32Element(nil, "foo", 1), ) doc := bsoncore.BuildDocument( nil, bsoncore.AppendDocumentElement(nil, "nested", innerDoc), ) want := primitive.M{ "nested": primitive.M{ "foo": int32(1), }, } testCases := []struct { name string registry *Registry }{ {"top level", topLevelRb.Build()}, {"embedded", embeddedRb.Build()}, } for _, tc := range testCases { var got interface{} vr := bsonrw.NewBSONDocumentReader(doc) val := reflect.ValueOf(&got).Elem() err := defaultEmptyInterfaceCodec.DecodeValue(DecodeContext{Registry: tc.registry}, vr, val) noerr(t, err) if !cmp.Equal(got, want) { t.Fatalf("got %v, want %v", got, want) } } }) t.Run("ancestor info is used over custom type map entry", func(t *testing.T) { // If a type map entry is registered for bsontype.EmbeddedDocument, the decoder should use ancestor // information if available instead of the registered entry. rb := NewRegistryBuilder() defaultValueEncoders.RegisterDefaultEncoders(rb) defaultValueDecoders.RegisterDefaultDecoders(rb) rb.RegisterTypeMapEntry(bsontype.EmbeddedDocument, reflect.TypeOf(primitive.M{})) reg := rb.Build() // build document {"nested": {"foo": 10}} inner := bsoncore.BuildDocument( nil, bsoncore.AppendInt32Element(nil, "foo", 10), ) doc := bsoncore.BuildDocument( nil, bsoncore.AppendDocumentElement(nil, "nested", inner), ) want := primitive.D{ {"nested", primitive.D{ {"foo", int32(10)}, }}, } var got primitive.D vr := bsonrw.NewBSONDocumentReader(doc) val := reflect.ValueOf(&got).Elem() err := defaultSliceCodec.DecodeValue(DecodeContext{Registry: reg}, vr, val) noerr(t, err) if !cmp.Equal(got, want) { t.Fatalf("got %v, want %v", got, want) } }) }) t.Run("decode errors contain key information", func(t *testing.T) { decodeValueError := errors.New("decode value error") emptyInterfaceErrorDecode := func(DecodeContext, bsonrw.ValueReader, reflect.Value) error { return decodeValueError } emptyInterfaceErrorRegistry := NewRegistryBuilder(). RegisterTypeDecoder(tEmpty, ValueDecoderFunc(emptyInterfaceErrorDecode)).Build() // Set up a document {foo: 10} and an error that would happen if the value were decoded into interface{} // using the registry defined above. docBytes := bsoncore.BuildDocumentFromElements( nil, bsoncore.AppendInt32Element(nil, "foo", 10), ) docEmptyInterfaceErr := &DecodeError{ keys: []string{"foo"}, wrapped: decodeValueError, } // Set up struct definitions where Foo maps to interface{} and string. When decoded using the registry defined // above, the interface{} struct will get an error when calling DecodeValue and the string struct will get an // error when looking up a decoder. type emptyInterfaceStruct struct { Foo interface{} } type stringStruct struct { Foo string } emptyInterfaceStructErr := &DecodeError{ keys: []string{"foo"}, wrapped: decodeValueError, } stringStructErr := &DecodeError{ keys: []string{"foo"}, wrapped: ErrNoDecoder{reflect.TypeOf("")}, } // Test a deeply nested struct mixed with maps and slices. // Build document {"first": {"second": {"randomKey": {"third": [{}, {"fourth": "value"}]}}}} type inner3 struct{ Fourth interface{} } type inner2 struct{ Third []inner3 } type inner1 struct{ Second map[string]inner2 } type outer struct{ First inner1 } inner3EmptyDoc := buildDocument(nil) inner3Doc := buildDocument(bsoncore.AppendStringElement(nil, "fourth", "value")) inner3Array := buildArray( // buildArray takes []byte so we first append() all of the values into a single []byte append( bsoncore.AppendDocumentElement(nil, "0", inner3EmptyDoc), bsoncore.AppendDocumentElement(nil, "1", inner3Doc)..., ), ) inner2Doc := buildDocument(bsoncore.AppendArrayElement(nil, "third", inner3Array)) inner2Map := buildDocument(bsoncore.AppendDocumentElement(nil, "randomKey", inner2Doc)) inner1Doc := buildDocument(bsoncore.AppendDocumentElement(nil, "second", inner2Map)) outerDoc := buildDocument(bsoncore.AppendDocumentElement(nil, "first", inner1Doc)) // Use a registry that has all default decoders with the custom interface{} decoder that always errors. nestedRegistryBuilder := NewRegistryBuilder() defaultValueDecoders.RegisterDefaultDecoders(nestedRegistryBuilder) nestedRegistry := nestedRegistryBuilder. RegisterTypeDecoder(tEmpty, ValueDecoderFunc(emptyInterfaceErrorDecode)). Build() nestedErr := &DecodeError{ keys: []string{"fourth", "1", "third", "randomKey", "second", "first"}, wrapped: decodeValueError, } testCases := []struct { name string val interface{} vr bsonrw.ValueReader registry *Registry // buildDefaultRegistry will be used if this is nil decoder ValueDecoder err error }{ { // DecodeValue error when decoding into a primitive.D. "primitive.D slice", primitive.D{}, bsonrw.NewBSONDocumentReader(docBytes), emptyInterfaceErrorRegistry, defaultSliceCodec, docEmptyInterfaceErr, }, { // DecodeValue error when decoding into a []string. "string slice", []string{}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array}, nil, defaultSliceCodec, &DecodeError{ keys: []string{"0"}, wrapped: errors.New("cannot decode array into a string type"), }, }, { // DecodeValue error when decoding into a primitive.E array. This should have the same behavior as // the "primitive.D slice" test above because both the defaultSliceCodec and ArrayDecodeValue use // the decodeD helper function. "primitive.D array", [1]primitive.E{}, bsonrw.NewBSONDocumentReader(docBytes), emptyInterfaceErrorRegistry, ValueDecoderFunc(dvd.ArrayDecodeValue), docEmptyInterfaceErr, }, { // DecodeValue error when decoding into a string array. This should have the same behavior as // the "primitive.D slice" test above because both the defaultSliceCodec and ArrayDecodeValue use // the decodeDefault helper function. "string array", [1]string{}, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array}, nil, ValueDecoderFunc(dvd.ArrayDecodeValue), &DecodeError{ keys: []string{"0"}, wrapped: errors.New("cannot decode array into a string type"), }, }, { // DecodeValue error when decoding into a map. "map", map[string]interface{}{}, bsonrw.NewBSONDocumentReader(docBytes), emptyInterfaceErrorRegistry, defaultMapCodec, docEmptyInterfaceErr, }, { // DecodeValue error when decoding into a struct. "struct - DecodeValue error", emptyInterfaceStruct{}, bsonrw.NewBSONDocumentReader(docBytes), emptyInterfaceErrorRegistry, defaultTestStructCodec, emptyInterfaceStructErr, }, { // ErrNoDecoder when decoding into a struct. // This test uses NewRegistryBuilder().Build rather than buildDefaultRegistry to ensure that there is // no decoder for strings. "struct - no decoder found", stringStruct{}, bsonrw.NewBSONDocumentReader(docBytes), NewRegistryBuilder().Build(), defaultTestStructCodec, stringStructErr, }, { "deeply nested struct", outer{}, bsonrw.NewBSONDocumentReader(outerDoc), nestedRegistry, defaultTestStructCodec, nestedErr, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { dc := DecodeContext{Registry: tc.registry} if dc.Registry == nil { dc.Registry = buildDefaultRegistry() } var val reflect.Value if rtype := reflect.TypeOf(tc.val); rtype != nil { val = reflect.New(rtype).Elem() } err := tc.decoder.DecodeValue(dc, tc.vr, val) assert.Equal(t, tc.err, err, "expected error %v, got %v", tc.err, err) }) } t.Run("keys are correctly reversed", func(t *testing.T) { innerBytes := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendInt32Element(nil, "bar", 10)) outerBytes := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendDocumentElement(nil, "foo", innerBytes)) type inner struct{ Bar string } type outer struct{ Foo inner } dc := DecodeContext{Registry: buildDefaultRegistry()} vr := bsonrw.NewBSONDocumentReader(outerBytes) val := reflect.New(reflect.TypeOf(outer{})).Elem() err := defaultTestStructCodec.DecodeValue(dc, vr, val) var decodeErr *DecodeError assert.True(t, errors.As(err, &decodeErr), "expected DecodeError, got %v of type %T", err, err) expectedKeys := []string{"foo", "bar"} assert.Equal(t, expectedKeys, decodeErr.Keys(), "expected keys slice %v, got %v", expectedKeys, decodeErr.Keys()) keyPath := strings.Join(expectedKeys, ".") assert.True(t, strings.Contains(decodeErr.Error(), keyPath), "expected error %v to contain key pattern %s", decodeErr, keyPath) }) }) t.Run("values are converted", func(t *testing.T) { // When decoding into a D or M, values must be converted if they are not being decoded to the default type. t.Run("D", func(t *testing.T) { trueValue := bsoncore.Value{ Type: bsontype.Boolean, Data: bsoncore.AppendBoolean(nil, true), } docBytes := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendBooleanElement(nil, "bool", true), bsoncore.BuildArrayElement(nil, "boolArray", trueValue), ) rb := NewRegistryBuilder() defaultValueDecoders.RegisterDefaultDecoders(rb) reg := rb.RegisterTypeMapEntry(bsontype.Boolean, reflect.TypeOf(mybool(true))).Build() dc := DecodeContext{Registry: reg} vr := bsonrw.NewBSONDocumentReader(docBytes) val := reflect.New(tD).Elem() err := defaultValueDecoders.DDecodeValue(dc, vr, val) assert.Nil(t, err, "DDecodeValue error: %v", err) want := primitive.D{ {"bool", mybool(true)}, {"boolArray", primitive.A{mybool(true)}}, } got := val.Interface().(primitive.D) assert.Equal(t, want, got, "want document %v, got %v", want, got) }) t.Run("M", func(t *testing.T) { docBytes := bsoncore.BuildDocumentFromElements(nil, bsoncore.AppendBooleanElement(nil, "bool", true), ) type myMap map[string]mybool dc := DecodeContext{Registry: buildDefaultRegistry()} vr := bsonrw.NewBSONDocumentReader(docBytes) val := reflect.New(reflect.TypeOf(myMap{})).Elem() err := defaultMapCodec.DecodeValue(dc, vr, val) assert.Nil(t, err, "DecodeValue error: %v", err) want := myMap{ "bool": mybool(true), } got := val.Interface().(myMap) assert.Equal(t, want, got, "expected map %v, got %v", want, got) }) }) } type testValueUnmarshaler struct { t bsontype.Type val []byte err error } func (tvu *testValueUnmarshaler) UnmarshalBSONValue(t bsontype.Type, val []byte) error { tvu.t, tvu.val = t, val return tvu.err } type testUnmarshaler struct { Val []byte Err error } func (tvu *testUnmarshaler) UnmarshalBSON(val []byte) error { tvu.Val = val return tvu.Err } func (tvu testValueUnmarshaler) Equal(tvu2 testValueUnmarshaler) bool { return tvu.t == tvu2.t && bytes.Equal(tvu.val, tvu2.val) } // buildDocumentArray inserts vals inside of an array inside of a document. func buildDocumentArray(fn func([]byte) []byte) []byte { aix, doc := bsoncore.AppendArrayElementStart(nil, "Z") doc = fn(doc) doc, _ = bsoncore.AppendArrayEnd(doc, aix) return buildDocument(doc) } func buildArray(vals []byte) []byte { aix, doc := bsoncore.AppendArrayStart(nil) doc = append(doc, vals...) doc, _ = bsoncore.AppendArrayEnd(doc, aix) return doc } func appendArrayElement(dst []byte, key string, vals []byte) []byte { aix, doc := bsoncore.AppendArrayElementStart(dst, key) doc = append(doc, vals...) doc, _ = bsoncore.AppendArrayEnd(doc, aix) return doc } // buildDocument inserts elems inside of a document. func buildDocument(elems []byte) []byte { idx, doc := bsoncore.AppendDocumentStart(nil) doc = append(doc, elems...) doc, _ = bsoncore.AppendDocumentEnd(doc, idx) return doc } func buildDefaultRegistry() *Registry { rb := NewRegistryBuilder() defaultValueEncoders.RegisterDefaultEncoders(rb) defaultValueDecoders.RegisterDefaultDecoders(rb) return rb.Build() }