mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-07 12:56:47 +00:00
1799d1111a
Rename build tag "proto1_legacy" -> "protolegacy" to be consistent with the "protoreflect" tag. Rename flag constant "Proto1Legacy" -> "ProtoLegacy" since it covers more than simply proto1 legacy features. For example, it covers alpha-features of proto3 that were eventually removed from the final proto3 release. Change-Id: I0f4fcbadd4b5a61c87645e2e5be11d187e59157c Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/189345 Reviewed-by: Damien Neil <dneil@google.com>
1532 lines
35 KiB
Go
1532 lines
35 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package prototext_test
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
|
|
"google.golang.org/protobuf/encoding/prototext"
|
|
"google.golang.org/protobuf/internal/flags"
|
|
pimpl "google.golang.org/protobuf/internal/impl"
|
|
"google.golang.org/protobuf/proto"
|
|
preg "google.golang.org/protobuf/reflect/protoregistry"
|
|
|
|
"google.golang.org/protobuf/encoding/testprotos/pb2"
|
|
"google.golang.org/protobuf/encoding/testprotos/pb3"
|
|
testpb "google.golang.org/protobuf/internal/testprotos/test"
|
|
weakpb "google.golang.org/protobuf/internal/testprotos/test/weak1"
|
|
"google.golang.org/protobuf/types/known/anypb"
|
|
)
|
|
|
|
func TestUnmarshal(t *testing.T) {
|
|
tests := []struct {
|
|
desc string
|
|
umo prototext.UnmarshalOptions
|
|
inputMessage proto.Message
|
|
inputText string
|
|
wantMessage proto.Message
|
|
wantErr bool // TODO: Verify error message content.
|
|
skip bool
|
|
}{{
|
|
desc: "proto2 empty message",
|
|
inputMessage: &pb2.Scalars{},
|
|
wantMessage: &pb2.Scalars{},
|
|
}, {
|
|
desc: "proto2 optional scalars set to zero values",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: `opt_bool: false
|
|
opt_int32: 0
|
|
opt_int64: 0
|
|
opt_uint32: 0
|
|
opt_uint64: 0
|
|
opt_sint32: 0
|
|
opt_sint64: 0
|
|
opt_fixed32: 0
|
|
opt_fixed64: 0
|
|
opt_sfixed32: 0
|
|
opt_sfixed64: 0
|
|
opt_float: 0
|
|
opt_double: 0
|
|
opt_bytes: ""
|
|
opt_string: ""
|
|
`,
|
|
wantMessage: &pb2.Scalars{
|
|
OptBool: proto.Bool(false),
|
|
OptInt32: proto.Int32(0),
|
|
OptInt64: proto.Int64(0),
|
|
OptUint32: proto.Uint32(0),
|
|
OptUint64: proto.Uint64(0),
|
|
OptSint32: proto.Int32(0),
|
|
OptSint64: proto.Int64(0),
|
|
OptFixed32: proto.Uint32(0),
|
|
OptFixed64: proto.Uint64(0),
|
|
OptSfixed32: proto.Int32(0),
|
|
OptSfixed64: proto.Int64(0),
|
|
OptFloat: proto.Float32(0),
|
|
OptDouble: proto.Float64(0),
|
|
OptBytes: []byte{},
|
|
OptString: proto.String(""),
|
|
},
|
|
}, {
|
|
desc: "proto3 scalars set to zero values",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: `s_bool: false
|
|
s_int32: 0
|
|
s_int64: 0
|
|
s_uint32: 0
|
|
s_uint64: 0
|
|
s_sint32: 0
|
|
s_sint64: 0
|
|
s_fixed32: 0
|
|
s_fixed64: 0
|
|
s_sfixed32: 0
|
|
s_sfixed64: 0
|
|
s_float: 0
|
|
s_double: 0
|
|
s_bytes: ""
|
|
s_string: ""
|
|
`,
|
|
wantMessage: &pb3.Scalars{},
|
|
}, {
|
|
desc: "proto2 optional scalars",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: `opt_bool: true
|
|
opt_int32: 255
|
|
opt_int64: 3735928559
|
|
opt_uint32: 0xff
|
|
opt_uint64: 0xdeadbeef
|
|
opt_sint32: -1001
|
|
opt_sint64: -0xffff
|
|
opt_fixed64: 64
|
|
opt_sfixed32: -32
|
|
opt_float: 1.234
|
|
opt_double: 1.23e+100
|
|
opt_bytes: "\xe8\xb0\xb7\xe6\xad\x8c"
|
|
opt_string: "谷歌"
|
|
`,
|
|
wantMessage: &pb2.Scalars{
|
|
OptBool: proto.Bool(true),
|
|
OptInt32: proto.Int32(0xff),
|
|
OptInt64: proto.Int64(0xdeadbeef),
|
|
OptUint32: proto.Uint32(0xff),
|
|
OptUint64: proto.Uint64(0xdeadbeef),
|
|
OptSint32: proto.Int32(-1001),
|
|
OptSint64: proto.Int64(-0xffff),
|
|
OptFixed64: proto.Uint64(64),
|
|
OptSfixed32: proto.Int32(-32),
|
|
OptFloat: proto.Float32(1.234),
|
|
OptDouble: proto.Float64(1.23e100),
|
|
OptBytes: []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
|
|
OptString: proto.String("谷歌"),
|
|
},
|
|
}, {
|
|
desc: "case sensitive",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: `S_BOOL: true`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto3 scalars",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: `s_bool: true
|
|
s_int32: 255
|
|
s_int64: 3735928559
|
|
s_uint32: 0xff
|
|
s_uint64: 0xdeadbeef
|
|
s_sint32: -1001
|
|
s_sint64: -0xffff
|
|
s_fixed64: 64
|
|
s_sfixed32: -32
|
|
s_float: 1.234
|
|
s_double: 1.23e+100
|
|
s_bytes: "\xe8\xb0\xb7\xe6\xad\x8c"
|
|
s_string: "谷歌"
|
|
`,
|
|
wantMessage: &pb3.Scalars{
|
|
SBool: true,
|
|
SInt32: 0xff,
|
|
SInt64: 0xdeadbeef,
|
|
SUint32: 0xff,
|
|
SUint64: 0xdeadbeef,
|
|
SSint32: -1001,
|
|
SSint64: -0xffff,
|
|
SFixed64: 64,
|
|
SSfixed32: -32,
|
|
SFloat: 1.234,
|
|
SDouble: 1.23e100,
|
|
SBytes: []byte("\xe8\xb0\xb7\xe6\xad\x8c"),
|
|
SString: "谷歌",
|
|
},
|
|
}, {
|
|
desc: "string with invalid UTF-8",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: `s_string: "abc\xff"`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 message contains unknown field",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: "unknown_field: 123",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto3 message contains unknown field",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "unknown_field: 456",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 numeric key field",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: "1: true",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto3 numeric key field",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "1: true",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid bool value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_bool: 123",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid int32 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_int32: not_a_num",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid int64 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_int64: 'not a num either'",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid uint32 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_fixed32: -42",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid uint64 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_uint64: -47",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid sint32 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_sint32: '42'",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid sint64 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_sint64: '-47'",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid fixed32 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_fixed32: -42",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid fixed64 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_fixed64: -42",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid sfixed32 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_sfixed32: 'not valid'",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "invalid sfixed64 value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_sfixed64: bad",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "float positive infinity",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_float: inf",
|
|
wantMessage: &pb3.Scalars{
|
|
SFloat: float32(math.Inf(1)),
|
|
},
|
|
}, {
|
|
desc: "float negative infinity",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_float: -inf",
|
|
wantMessage: &pb3.Scalars{
|
|
SFloat: float32(math.Inf(-1)),
|
|
},
|
|
}, {
|
|
desc: "double positive infinity",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_double: inf",
|
|
wantMessage: &pb3.Scalars{
|
|
SDouble: math.Inf(1),
|
|
},
|
|
}, {
|
|
desc: "double negative infinity",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_double: -inf",
|
|
wantMessage: &pb3.Scalars{
|
|
SDouble: math.Inf(-1),
|
|
},
|
|
}, {
|
|
desc: "invalid string value",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_string: invalid_string",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 bytes set to empty string",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: "opt_bytes: ''",
|
|
wantMessage: &pb2.Scalars{
|
|
OptBytes: []byte(""),
|
|
},
|
|
}, {
|
|
desc: "proto3 bytes set to empty string",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: "s_bytes: ''",
|
|
wantMessage: &pb3.Scalars{},
|
|
}, {
|
|
desc: "proto2 duplicate singular field",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: `
|
|
opt_bool: true
|
|
opt_bool: false
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 more duplicate singular field",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: `
|
|
opt_bool: true
|
|
opt_string: "hello"
|
|
opt_bool: false
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 invalid singular field",
|
|
inputMessage: &pb2.Scalars{},
|
|
inputText: `
|
|
opt_bool: [true, false]
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto3 duplicate singular field",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: `
|
|
s_bool: false
|
|
s_bool: true
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto3 more duplicate singular field",
|
|
inputMessage: &pb3.Scalars{},
|
|
inputText: `
|
|
s_bool: false
|
|
s_string: ""
|
|
s_bool: true
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 enum",
|
|
inputMessage: &pb2.Enums{},
|
|
inputText: `
|
|
opt_enum: ONE
|
|
opt_nested_enum: UNO
|
|
`,
|
|
wantMessage: &pb2.Enums{
|
|
OptEnum: pb2.Enum_ONE.Enum(),
|
|
OptNestedEnum: pb2.Enums_UNO.Enum(),
|
|
},
|
|
}, {
|
|
desc: "proto2 enum set to numeric values",
|
|
inputMessage: &pb2.Enums{},
|
|
inputText: `
|
|
opt_enum: 2
|
|
opt_nested_enum: 2
|
|
`,
|
|
wantMessage: &pb2.Enums{
|
|
OptEnum: pb2.Enum_TWO.Enum(),
|
|
OptNestedEnum: pb2.Enums_DOS.Enum(),
|
|
},
|
|
}, {
|
|
desc: "proto2 enum set to unnamed numeric values",
|
|
inputMessage: &pb2.Enums{},
|
|
inputText: `
|
|
opt_enum: 101
|
|
opt_nested_enum: -101
|
|
`,
|
|
wantMessage: &pb2.Enums{
|
|
OptEnum: pb2.Enum(101).Enum(),
|
|
OptNestedEnum: pb2.Enums_NestedEnum(-101).Enum(),
|
|
},
|
|
}, {
|
|
desc: "proto2 enum set to invalid named",
|
|
inputMessage: &pb2.Enums{},
|
|
inputText: `
|
|
opt_enum: UNNAMED
|
|
opt_nested_enum: UNNAMED_TOO
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto3 enum name value",
|
|
inputMessage: &pb3.Enums{},
|
|
inputText: `
|
|
s_enum: ONE
|
|
s_nested_enum: DIEZ
|
|
`,
|
|
wantMessage: &pb3.Enums{
|
|
SEnum: pb3.Enum_ONE,
|
|
SNestedEnum: pb3.Enums_DIEZ,
|
|
},
|
|
}, {
|
|
desc: "proto3 enum numeric value",
|
|
inputMessage: &pb3.Enums{},
|
|
inputText: `
|
|
s_enum: 2
|
|
s_nested_enum: 2
|
|
`,
|
|
wantMessage: &pb3.Enums{
|
|
SEnum: pb3.Enum_TWO,
|
|
SNestedEnum: pb3.Enums_DOS,
|
|
},
|
|
}, {
|
|
desc: "proto3 enum unnamed numeric value",
|
|
inputMessage: &pb3.Enums{},
|
|
inputText: `
|
|
s_enum: 0x7fffffff
|
|
s_nested_enum: -0x80000000
|
|
`,
|
|
wantMessage: &pb3.Enums{
|
|
SEnum: 0x7fffffff,
|
|
SNestedEnum: -0x80000000,
|
|
},
|
|
}, {
|
|
desc: "proto2 nested empty messages",
|
|
inputMessage: &pb2.Nests{},
|
|
inputText: `
|
|
opt_nested: {}
|
|
OptGroup: {}
|
|
`,
|
|
wantMessage: &pb2.Nests{
|
|
OptNested: &pb2.Nested{},
|
|
Optgroup: &pb2.Nests_OptGroup{},
|
|
},
|
|
}, {
|
|
desc: "group field name",
|
|
inputMessage: &pb2.Nests{},
|
|
inputText: `optgroup: {}`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "proto2 nested messages",
|
|
inputMessage: &pb2.Nests{},
|
|
inputText: `
|
|
opt_nested: {
|
|
opt_string: "nested message"
|
|
opt_nested: {
|
|
opt_string: "another nested message"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: &pb2.Nests{
|
|
OptNested: &pb2.Nested{
|
|
OptString: proto.String("nested message"),
|
|
OptNested: &pb2.Nested{
|
|
OptString: proto.String("another nested message"),
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "proto3 nested empty message",
|
|
inputMessage: &pb3.Nests{},
|
|
inputText: "s_nested: {}",
|
|
wantMessage: &pb3.Nests{
|
|
SNested: &pb3.Nested{},
|
|
},
|
|
}, {
|
|
desc: "proto3 nested message",
|
|
inputMessage: &pb3.Nests{},
|
|
inputText: `
|
|
s_nested: {
|
|
s_string: "nested message"
|
|
s_nested: {
|
|
s_string: "another nested message"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Nests{
|
|
SNested: &pb3.Nested{
|
|
SString: "nested message",
|
|
SNested: &pb3.Nested{
|
|
SString: "another nested message",
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "proto3 nested message contains invalid UTF-8",
|
|
inputMessage: &pb3.Nests{},
|
|
inputText: `s_nested: {
|
|
s_string: "abc\xff"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "oneof set to empty string",
|
|
inputMessage: &pb3.Oneofs{},
|
|
inputText: "oneof_string: ''",
|
|
wantMessage: &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofString{},
|
|
},
|
|
}, {
|
|
desc: "oneof set to string",
|
|
inputMessage: &pb3.Oneofs{},
|
|
inputText: "oneof_string: 'hello'",
|
|
wantMessage: &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofString{
|
|
OneofString: "hello",
|
|
},
|
|
},
|
|
}, {
|
|
desc: "oneof set to enum",
|
|
inputMessage: &pb3.Oneofs{},
|
|
inputText: "oneof_enum: TEN",
|
|
wantMessage: &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofEnum{
|
|
OneofEnum: pb3.Enum_TEN,
|
|
},
|
|
},
|
|
}, {
|
|
desc: "oneof set to empty message",
|
|
inputMessage: &pb3.Oneofs{},
|
|
inputText: "oneof_nested: {}",
|
|
wantMessage: &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofNested{
|
|
OneofNested: &pb3.Nested{},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "oneof set to message",
|
|
inputMessage: &pb3.Oneofs{},
|
|
inputText: `
|
|
oneof_nested: {
|
|
s_string: "nested message"
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofNested{
|
|
OneofNested: &pb3.Nested{
|
|
SString: "nested message",
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "oneof set to more than one field",
|
|
inputMessage: &pb3.Oneofs{},
|
|
inputText: `
|
|
oneof_enum: ZERO
|
|
oneof_string: "hello"
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "repeated scalar using same field name",
|
|
inputMessage: &pb2.Repeats{},
|
|
inputText: `
|
|
rpt_string: "a"
|
|
rpt_string: "b"
|
|
rpt_int32: 0xff
|
|
rpt_float: 1.23
|
|
rpt_bytes: "bytes"
|
|
`,
|
|
wantMessage: &pb2.Repeats{
|
|
RptString: []string{"a", "b"},
|
|
RptInt32: []int32{0xff},
|
|
RptFloat: []float32{1.23},
|
|
RptBytes: [][]byte{[]byte("bytes")},
|
|
},
|
|
}, {
|
|
desc: "repeated using mix of [] and repeated field name",
|
|
inputMessage: &pb2.Repeats{},
|
|
inputText: `
|
|
rpt_string: "a"
|
|
rpt_bool: true
|
|
rpt_string: ["x", "y"]
|
|
rpt_bool: [ false, true ]
|
|
rpt_string: "b"
|
|
`,
|
|
wantMessage: &pb2.Repeats{
|
|
RptString: []string{"a", "x", "y", "b"},
|
|
RptBool: []bool{true, false, true},
|
|
},
|
|
}, {
|
|
desc: "repeated contains invalid UTF-8",
|
|
inputMessage: &pb2.Repeats{},
|
|
inputText: `rpt_string: "abc\xff"`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "repeated enums",
|
|
inputMessage: &pb2.Enums{},
|
|
inputText: `
|
|
rpt_enum: TEN
|
|
rpt_enum: 1
|
|
rpt_nested_enum: [DOS, 2]
|
|
rpt_enum: 42
|
|
rpt_nested_enum: -47
|
|
`,
|
|
wantMessage: &pb2.Enums{
|
|
RptEnum: []pb2.Enum{pb2.Enum_TEN, pb2.Enum_ONE, 42},
|
|
RptNestedEnum: []pb2.Enums_NestedEnum{pb2.Enums_DOS, pb2.Enums_DOS, -47},
|
|
},
|
|
}, {
|
|
desc: "repeated nested messages",
|
|
inputMessage: &pb2.Nests{},
|
|
inputText: `
|
|
rpt_nested: {
|
|
opt_string: "repeat nested one"
|
|
}
|
|
rpt_nested: {
|
|
opt_string: "repeat nested two"
|
|
opt_nested: {
|
|
opt_string: "inside repeat nested two"
|
|
}
|
|
}
|
|
rpt_nested: {}
|
|
`,
|
|
wantMessage: &pb2.Nests{
|
|
RptNested: []*pb2.Nested{
|
|
{
|
|
OptString: proto.String("repeat nested one"),
|
|
},
|
|
{
|
|
OptString: proto.String("repeat nested two"),
|
|
OptNested: &pb2.Nested{
|
|
OptString: proto.String("inside repeat nested two"),
|
|
},
|
|
},
|
|
{},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "repeated group fields",
|
|
inputMessage: &pb2.Nests{},
|
|
inputText: `
|
|
RptGroup: {
|
|
rpt_string: "hello"
|
|
rpt_string: "world"
|
|
}
|
|
RptGroup: {}
|
|
`,
|
|
wantMessage: &pb2.Nests{
|
|
Rptgroup: []*pb2.Nests_RptGroup{
|
|
{
|
|
RptString: []string{"hello", "world"},
|
|
},
|
|
{},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map fields 1",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: -101
|
|
value: "-101"
|
|
}
|
|
int32_to_str: {
|
|
key: 0
|
|
value: "zero"
|
|
}
|
|
bool_to_uint32: {
|
|
key: false
|
|
value: 101
|
|
}
|
|
int32_to_str: {
|
|
key: 255
|
|
value: "0xff"
|
|
}
|
|
bool_to_uint32: {
|
|
key: true
|
|
value: 42
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
-101: "-101",
|
|
0xff: "0xff",
|
|
0: "zero",
|
|
},
|
|
BoolToUint32: map[bool]uint32{
|
|
true: 42,
|
|
false: 101,
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map fields 2",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
uint64_to_enum: {
|
|
key: 1
|
|
value: ONE
|
|
}
|
|
uint64_to_enum: {
|
|
key: 2
|
|
value: 2
|
|
}
|
|
uint64_to_enum: {
|
|
key: 10
|
|
value: 101
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Uint64ToEnum: map[uint64]pb3.Enum{
|
|
1: pb3.Enum_ONE,
|
|
2: pb3.Enum_TWO,
|
|
10: 101,
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map fields 3",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
str_to_nested: {
|
|
key: "nested_one"
|
|
value: {
|
|
s_string: "nested in a map"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
StrToNested: map[string]*pb3.Nested{
|
|
"nested_one": &pb3.Nested{
|
|
SString: "nested in a map",
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map fields 4",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
str_to_oneofs: {
|
|
key: "nested"
|
|
value: {
|
|
oneof_nested: {
|
|
s_string: "nested oneof in map field value"
|
|
}
|
|
}
|
|
}
|
|
str_to_oneofs: {
|
|
key: "string"
|
|
value: {
|
|
oneof_string: "hello"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
StrToOneofs: map[string]*pb3.Oneofs{
|
|
"string": &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofString{
|
|
OneofString: "hello",
|
|
},
|
|
},
|
|
"nested": &pb3.Oneofs{
|
|
Union: &pb3.Oneofs_OneofNested{
|
|
OneofNested: &pb3.Nested{
|
|
SString: "nested oneof in map field value",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map contains duplicate keys",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 0
|
|
value: "cero"
|
|
}
|
|
int32_to_str: {
|
|
key: 0
|
|
value: "zero"
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
0: "zero",
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map contains duplicate key fields",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 0
|
|
key: 1
|
|
value: "cero"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map contains duplicate value fields",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 1
|
|
value: "cero"
|
|
value: "uno"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map contains missing key",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
value: "zero"
|
|
}
|
|
bool_to_uint32: {
|
|
value: 47
|
|
}
|
|
str_to_nested: {
|
|
value: {}
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
0: "zero",
|
|
},
|
|
BoolToUint32: map[bool]uint32{
|
|
false: 47,
|
|
},
|
|
StrToNested: map[string]*pb3.Nested{
|
|
"": {},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map contains missing value",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 100
|
|
}
|
|
bool_to_uint32: {
|
|
key: true
|
|
}
|
|
uint64_to_enum: {
|
|
key: 101
|
|
}
|
|
str_to_nested: {
|
|
key: "hello"
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
100: "",
|
|
},
|
|
BoolToUint32: map[bool]uint32{
|
|
true: 0,
|
|
},
|
|
Uint64ToEnum: map[uint64]pb3.Enum{
|
|
101: pb3.Enum_ZERO,
|
|
},
|
|
StrToNested: map[string]*pb3.Nested{
|
|
"hello": {},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map contains missing key and value",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {}
|
|
bool_to_uint32: {}
|
|
uint64_to_enum: {}
|
|
str_to_nested: {}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
0: "",
|
|
},
|
|
BoolToUint32: map[bool]uint32{
|
|
false: 0,
|
|
},
|
|
Uint64ToEnum: map[uint64]pb3.Enum{
|
|
0: pb3.Enum_ZERO,
|
|
},
|
|
StrToNested: map[string]*pb3.Nested{
|
|
"": {},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map contains overriding entries",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 0
|
|
}
|
|
int32_to_str: {
|
|
value: "empty"
|
|
}
|
|
int32_to_str: {}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
0: "",
|
|
},
|
|
},
|
|
}, {
|
|
desc: "map field value contains invalid UTF-8",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `int32_to_str: {
|
|
key: 101
|
|
value: "abc\xff"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map field key contains invalid UTF-8",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `str_to_nested: {
|
|
key: "abc\xff"
|
|
value: {}
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map contains unknown field",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 0
|
|
value: "cero"
|
|
unknown: "bad"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map contains extension-like key field",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
[key]: 10
|
|
value: "ten"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map contains invalid key",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: "invalid"
|
|
value: "cero"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map contains invalid value",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 100
|
|
value: 101
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "map using mix of [] and repeated",
|
|
inputMessage: &pb3.Maps{},
|
|
inputText: `
|
|
int32_to_str: {
|
|
key: 1
|
|
value: "one"
|
|
}
|
|
int32_to_str: [
|
|
{
|
|
key: 2
|
|
value: "not this"
|
|
},
|
|
{
|
|
},
|
|
{
|
|
key: 3
|
|
value: "three"
|
|
}
|
|
]
|
|
int32_to_str: {
|
|
key: 2
|
|
value: "two"
|
|
}
|
|
`,
|
|
wantMessage: &pb3.Maps{
|
|
Int32ToStr: map[int32]string{
|
|
0: "",
|
|
1: "one",
|
|
2: "two",
|
|
3: "three",
|
|
},
|
|
},
|
|
}, {
|
|
desc: "required fields not set",
|
|
inputMessage: &pb2.Requireds{},
|
|
wantErr: true,
|
|
}, {
|
|
desc: "required field set",
|
|
inputMessage: &pb2.PartialRequired{},
|
|
inputText: "req_string: 'this is required'",
|
|
wantMessage: &pb2.PartialRequired{
|
|
ReqString: proto.String("this is required"),
|
|
},
|
|
}, {
|
|
desc: "required fields partially set",
|
|
inputMessage: &pb2.Requireds{},
|
|
inputText: `
|
|
req_bool: false
|
|
req_sfixed64: 3203386110
|
|
req_string: "hello"
|
|
req_enum: ONE
|
|
`,
|
|
wantMessage: &pb2.Requireds{
|
|
ReqBool: proto.Bool(false),
|
|
ReqSfixed64: proto.Int64(0xbeefcafe),
|
|
ReqString: proto.String("hello"),
|
|
ReqEnum: pb2.Enum_ONE.Enum(),
|
|
},
|
|
wantErr: true,
|
|
}, {
|
|
desc: "required fields partially set with AllowPartial",
|
|
umo: prototext.UnmarshalOptions{AllowPartial: true},
|
|
inputMessage: &pb2.Requireds{},
|
|
inputText: `
|
|
req_bool: false
|
|
req_sfixed64: 3203386110
|
|
req_string: "hello"
|
|
req_enum: ONE
|
|
`,
|
|
wantMessage: &pb2.Requireds{
|
|
ReqBool: proto.Bool(false),
|
|
ReqSfixed64: proto.Int64(0xbeefcafe),
|
|
ReqString: proto.String("hello"),
|
|
ReqEnum: pb2.Enum_ONE.Enum(),
|
|
},
|
|
}, {
|
|
desc: "required fields all set",
|
|
inputMessage: &pb2.Requireds{},
|
|
inputText: `
|
|
req_bool: false
|
|
req_sfixed64: 0
|
|
req_double: 0
|
|
req_string: ""
|
|
req_enum: ONE
|
|
req_nested: {}
|
|
`,
|
|
wantMessage: &pb2.Requireds{
|
|
ReqBool: proto.Bool(false),
|
|
ReqSfixed64: proto.Int64(0),
|
|
ReqDouble: proto.Float64(0),
|
|
ReqString: proto.String(""),
|
|
ReqEnum: pb2.Enum_ONE.Enum(),
|
|
ReqNested: &pb2.Nested{},
|
|
},
|
|
}, {
|
|
desc: "indirect required field",
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: "opt_nested: {}",
|
|
wantMessage: &pb2.IndirectRequired{
|
|
OptNested: &pb2.NestedWithRequired{},
|
|
},
|
|
wantErr: true,
|
|
}, {
|
|
desc: "indirect required field with AllowPartial",
|
|
umo: prototext.UnmarshalOptions{AllowPartial: true},
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: "opt_nested: {}",
|
|
wantMessage: &pb2.IndirectRequired{
|
|
OptNested: &pb2.NestedWithRequired{},
|
|
},
|
|
}, {
|
|
desc: "indirect required field in repeated",
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: `
|
|
rpt_nested: {
|
|
req_string: "one"
|
|
}
|
|
rpt_nested: {}
|
|
`,
|
|
wantMessage: &pb2.IndirectRequired{
|
|
RptNested: []*pb2.NestedWithRequired{
|
|
{
|
|
ReqString: proto.String("one"),
|
|
},
|
|
{},
|
|
},
|
|
},
|
|
wantErr: true,
|
|
}, {
|
|
desc: "indirect required field in repeated with AllowPartial",
|
|
umo: prototext.UnmarshalOptions{AllowPartial: true},
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: `
|
|
rpt_nested: {
|
|
req_string: "one"
|
|
}
|
|
rpt_nested: {}
|
|
`,
|
|
wantMessage: &pb2.IndirectRequired{
|
|
RptNested: []*pb2.NestedWithRequired{
|
|
{
|
|
ReqString: proto.String("one"),
|
|
},
|
|
{},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "indirect required field in map",
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: `
|
|
str_to_nested: {
|
|
key: "missing"
|
|
}
|
|
str_to_nested: {
|
|
key: "contains"
|
|
value: {
|
|
req_string: "here"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: &pb2.IndirectRequired{
|
|
StrToNested: map[string]*pb2.NestedWithRequired{
|
|
"missing": &pb2.NestedWithRequired{},
|
|
"contains": &pb2.NestedWithRequired{
|
|
ReqString: proto.String("here"),
|
|
},
|
|
},
|
|
},
|
|
wantErr: true,
|
|
}, {
|
|
desc: "indirect required field in map with AllowPartial",
|
|
umo: prototext.UnmarshalOptions{AllowPartial: true},
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: `
|
|
str_to_nested: {
|
|
key: "missing"
|
|
}
|
|
str_to_nested: {
|
|
key: "contains"
|
|
value: {
|
|
req_string: "here"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: &pb2.IndirectRequired{
|
|
StrToNested: map[string]*pb2.NestedWithRequired{
|
|
"missing": &pb2.NestedWithRequired{},
|
|
"contains": &pb2.NestedWithRequired{
|
|
ReqString: proto.String("here"),
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "indirect required field in oneof",
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: `oneof_nested: {}
|
|
`,
|
|
wantMessage: &pb2.IndirectRequired{
|
|
Union: &pb2.IndirectRequired_OneofNested{
|
|
OneofNested: &pb2.NestedWithRequired{},
|
|
},
|
|
},
|
|
wantErr: true,
|
|
}, {
|
|
desc: "indirect required field in oneof with AllowPartial",
|
|
umo: prototext.UnmarshalOptions{AllowPartial: true},
|
|
inputMessage: &pb2.IndirectRequired{},
|
|
inputText: `oneof_nested: {}
|
|
`,
|
|
wantMessage: &pb2.IndirectRequired{
|
|
Union: &pb2.IndirectRequired_OneofNested{
|
|
OneofNested: &pb2.NestedWithRequired{},
|
|
},
|
|
},
|
|
}, {
|
|
desc: "ignore reserved field",
|
|
inputMessage: &pb2.Nests{},
|
|
inputText: "reserved_field: 'ignore this'",
|
|
wantMessage: &pb2.Nests{},
|
|
}, {
|
|
desc: "extensions of non-repeated fields",
|
|
inputMessage: &pb2.Extensions{},
|
|
inputText: `opt_string: "non-extension field"
|
|
[pb2.opt_ext_bool]: true
|
|
opt_bool: true
|
|
[pb2.opt_ext_nested]: {
|
|
opt_string: "nested in an extension"
|
|
opt_nested: {
|
|
opt_string: "another nested in an extension"
|
|
}
|
|
}
|
|
[pb2.opt_ext_string]: "extension field"
|
|
opt_int32: 42
|
|
[pb2.opt_ext_enum]: TEN
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.Extensions{
|
|
OptString: proto.String("non-extension field"),
|
|
OptBool: proto.Bool(true),
|
|
OptInt32: proto.Int32(42),
|
|
}
|
|
proto.SetExtension(m, pb2.E_OptExtBool, true)
|
|
proto.SetExtension(m, pb2.E_OptExtString, "extension field")
|
|
proto.SetExtension(m, pb2.E_OptExtEnum, pb2.Enum_TEN)
|
|
proto.SetExtension(m, pb2.E_OptExtNested, &pb2.Nested{
|
|
OptString: proto.String("nested in an extension"),
|
|
OptNested: &pb2.Nested{
|
|
OptString: proto.String("another nested in an extension"),
|
|
},
|
|
})
|
|
return m
|
|
}(),
|
|
}, {
|
|
desc: "extension field contains invalid UTF-8",
|
|
inputMessage: &pb2.Extensions{},
|
|
inputText: `[pb2.opt_ext_string]: "abc\xff"`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "extensions of repeated fields",
|
|
inputMessage: &pb2.Extensions{},
|
|
inputText: `[pb2.rpt_ext_enum]: TEN
|
|
[pb2.rpt_ext_enum]: 101
|
|
[pb2.rpt_ext_fixed32]: 42
|
|
[pb2.rpt_ext_enum]: ONE
|
|
[pb2.rpt_ext_nested]: {
|
|
opt_string: "one"
|
|
}
|
|
[pb2.rpt_ext_nested]: {
|
|
opt_string: "two"
|
|
}
|
|
[pb2.rpt_ext_fixed32]: 47
|
|
[pb2.rpt_ext_nested]: {
|
|
opt_string: "three"
|
|
}
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.Extensions{}
|
|
proto.SetExtension(m, pb2.E_RptExtEnum, &[]pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
|
|
proto.SetExtension(m, pb2.E_RptExtFixed32, &[]uint32{42, 47})
|
|
proto.SetExtension(m, pb2.E_RptExtNested, &[]*pb2.Nested{
|
|
&pb2.Nested{OptString: proto.String("one")},
|
|
&pb2.Nested{OptString: proto.String("two")},
|
|
&pb2.Nested{OptString: proto.String("three")},
|
|
})
|
|
return m
|
|
}(),
|
|
}, {
|
|
desc: "extensions of non-repeated fields in another message",
|
|
inputMessage: &pb2.Extensions{},
|
|
inputText: `[pb2.ExtensionsContainer.opt_ext_bool]: true
|
|
[pb2.ExtensionsContainer.opt_ext_enum]: TEN
|
|
[pb2.ExtensionsContainer.opt_ext_nested]: {
|
|
opt_string: "nested in an extension"
|
|
opt_nested: {
|
|
opt_string: "another nested in an extension"
|
|
}
|
|
}
|
|
[pb2.ExtensionsContainer.opt_ext_string]: "extension field"
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.Extensions{}
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtBool, true)
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtString, "extension field")
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtEnum, pb2.Enum_TEN)
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_OptExtNested, &pb2.Nested{
|
|
OptString: proto.String("nested in an extension"),
|
|
OptNested: &pb2.Nested{
|
|
OptString: proto.String("another nested in an extension"),
|
|
},
|
|
})
|
|
return m
|
|
}(),
|
|
}, {
|
|
desc: "extensions of repeated fields in another message",
|
|
inputMessage: &pb2.Extensions{},
|
|
inputText: `opt_string: "non-extension field"
|
|
opt_bool: true
|
|
opt_int32: 42
|
|
[pb2.ExtensionsContainer.rpt_ext_nested]: {
|
|
opt_string: "one"
|
|
}
|
|
[pb2.ExtensionsContainer.rpt_ext_enum]: TEN
|
|
[pb2.ExtensionsContainer.rpt_ext_nested]: {
|
|
opt_string: "two"
|
|
}
|
|
[pb2.ExtensionsContainer.rpt_ext_enum]: 101
|
|
[pb2.ExtensionsContainer.rpt_ext_string]: "hello"
|
|
[pb2.ExtensionsContainer.rpt_ext_enum]: ONE
|
|
[pb2.ExtensionsContainer.rpt_ext_nested]: {
|
|
opt_string: "three"
|
|
}
|
|
[pb2.ExtensionsContainer.rpt_ext_string]: "world"
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.Extensions{
|
|
OptString: proto.String("non-extension field"),
|
|
OptBool: proto.Bool(true),
|
|
OptInt32: proto.Int32(42),
|
|
}
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtEnum, &[]pb2.Enum{pb2.Enum_TEN, 101, pb2.Enum_ONE})
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtString, &[]string{"hello", "world"})
|
|
proto.SetExtension(m, pb2.E_ExtensionsContainer_RptExtNested, &[]*pb2.Nested{
|
|
&pb2.Nested{OptString: proto.String("one")},
|
|
&pb2.Nested{OptString: proto.String("two")},
|
|
&pb2.Nested{OptString: proto.String("three")},
|
|
})
|
|
return m
|
|
}(),
|
|
}, {
|
|
desc: "invalid extension field name",
|
|
inputMessage: &pb2.Extensions{},
|
|
inputText: "[pb2.invalid_message_field]: true",
|
|
wantErr: true,
|
|
}, {
|
|
desc: "MessageSet",
|
|
inputMessage: &pb2.MessageSet{},
|
|
inputText: `
|
|
[pb2.MessageSetExtension]: {
|
|
opt_string: "a messageset extension"
|
|
}
|
|
[pb2.MessageSetExtension.ext_nested]: {
|
|
opt_string: "just a regular extension"
|
|
}
|
|
[pb2.MessageSetExtension.not_message_set_extension]: {
|
|
opt_string: "not a messageset extension"
|
|
}
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.MessageSet{}
|
|
proto.SetExtension(m, pb2.E_MessageSetExtension_MessageSetExtension, &pb2.MessageSetExtension{
|
|
OptString: proto.String("a messageset extension"),
|
|
})
|
|
proto.SetExtension(m, pb2.E_MessageSetExtension_NotMessageSetExtension, &pb2.MessageSetExtension{
|
|
OptString: proto.String("not a messageset extension"),
|
|
})
|
|
proto.SetExtension(m, pb2.E_MessageSetExtension_ExtNested, &pb2.Nested{
|
|
OptString: proto.String("just a regular extension"),
|
|
})
|
|
return m
|
|
}(),
|
|
skip: !flags.ProtoLegacy,
|
|
}, {
|
|
desc: "not real MessageSet 1",
|
|
inputMessage: &pb2.FakeMessageSet{},
|
|
inputText: `
|
|
[pb2.FakeMessageSetExtension.message_set_extension]: {
|
|
opt_string: "not a messageset extension"
|
|
}
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.FakeMessageSet{}
|
|
proto.SetExtension(m, pb2.E_FakeMessageSetExtension_MessageSetExtension, &pb2.FakeMessageSetExtension{
|
|
OptString: proto.String("not a messageset extension"),
|
|
})
|
|
return m
|
|
}(),
|
|
skip: !flags.ProtoLegacy,
|
|
}, {
|
|
desc: "not real MessageSet 2",
|
|
inputMessage: &pb2.FakeMessageSet{},
|
|
inputText: `
|
|
[pb2.FakeMessageSetExtension]: {
|
|
opt_string: "not a messageset extension"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
skip: !flags.ProtoLegacy,
|
|
}, {
|
|
desc: "not real MessageSet 3",
|
|
inputMessage: &pb2.MessageSet{},
|
|
inputText: `
|
|
[pb2.message_set_extension]: {
|
|
opt_string: "another not a messageset extension"
|
|
}`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.MessageSet{}
|
|
proto.SetExtension(m, pb2.E_MessageSetExtension, &pb2.FakeMessageSetExtension{
|
|
OptString: proto.String("another not a messageset extension"),
|
|
})
|
|
return m
|
|
}(),
|
|
skip: !flags.ProtoLegacy,
|
|
}, {
|
|
desc: "Any not expanded",
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `
|
|
type_url: "pb2.Nested"
|
|
value: "some bytes"
|
|
`,
|
|
wantMessage: &anypb.Any{
|
|
TypeUrl: "pb2.Nested",
|
|
Value: []byte("some bytes"),
|
|
},
|
|
}, {
|
|
desc: "Any not expanded missing value",
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `type_url: "pb2.Nested"`,
|
|
wantMessage: &anypb.Any{
|
|
TypeUrl: "pb2.Nested",
|
|
},
|
|
}, {
|
|
desc: "Any not expanded missing type_url",
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `value: "some bytes"`,
|
|
wantMessage: &anypb.Any{
|
|
Value: []byte("some bytes"),
|
|
},
|
|
}, {
|
|
desc: "Any expanded",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `
|
|
[foobar/pb2.Nested]: {
|
|
opt_string: "embedded inside Any"
|
|
opt_nested: {
|
|
opt_string: "inception"
|
|
}
|
|
}
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.Nested{
|
|
OptString: proto.String("embedded inside Any"),
|
|
OptNested: &pb2.Nested{
|
|
OptString: proto.String("inception"),
|
|
},
|
|
}
|
|
b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m)
|
|
if err != nil {
|
|
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
|
|
}
|
|
return &anypb.Any{
|
|
TypeUrl: "foobar/pb2.Nested",
|
|
Value: b,
|
|
}
|
|
}(),
|
|
}, {
|
|
desc: "Any expanded with empty value",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `[foo.com/pb2.Nested]: {}`,
|
|
wantMessage: &anypb.Any{
|
|
TypeUrl: "foo.com/pb2.Nested",
|
|
},
|
|
}, {
|
|
desc: "Any expanded with missing required",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.PartialRequired{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `
|
|
[pb2.PartialRequired]: {
|
|
opt_string: "embedded inside Any"
|
|
}
|
|
`,
|
|
wantMessage: func() proto.Message {
|
|
m := &pb2.PartialRequired{
|
|
OptString: proto.String("embedded inside Any"),
|
|
}
|
|
b, err := proto.MarshalOptions{
|
|
AllowPartial: true,
|
|
Deterministic: true,
|
|
}.Marshal(m)
|
|
if err != nil {
|
|
t.Fatalf("error in binary marshaling message for Any.value: %v", err)
|
|
}
|
|
return &anypb.Any{
|
|
TypeUrl: "pb2.PartialRequired",
|
|
Value: b,
|
|
}
|
|
}(),
|
|
}, {
|
|
desc: "Any with invalid UTF-8",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb3.Nested{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `
|
|
[pb3.Nested]: {
|
|
s_string: "abc\xff"
|
|
}
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "Any expanded with unregistered type",
|
|
umo: prototext.UnmarshalOptions{Resolver: preg.NewTypes()},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `[SomeMessage]: {}`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "Any expanded with invalid value",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `[pb2.Nested]: 123`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "Any expanded with unknown fields",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `
|
|
[pb2.Nested]: {}
|
|
unknown: ""
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "Any contains expanded and unexpanded fields",
|
|
umo: prototext.UnmarshalOptions{
|
|
Resolver: preg.NewTypes(pimpl.Export{}.MessageTypeOf(&pb2.Nested{})),
|
|
},
|
|
inputMessage: &anypb.Any{},
|
|
inputText: `
|
|
[pb2.Nested]: {}
|
|
type_url: "pb2.Nested"
|
|
`,
|
|
wantErr: true,
|
|
}, {
|
|
desc: "weak fields",
|
|
inputMessage: &testpb.TestWeak{},
|
|
inputText: `weak_message1:{a:1}`,
|
|
wantMessage: func() *testpb.TestWeak {
|
|
m := new(testpb.TestWeak)
|
|
m.SetWeakMessage1(&weakpb.WeakImportMessage1{A: proto.Int32(1)})
|
|
return m
|
|
}(),
|
|
skip: !flags.ProtoLegacy,
|
|
}, {
|
|
desc: "weak fields; unknown field",
|
|
inputMessage: &testpb.TestWeak{},
|
|
inputText: `weak_message1:{a:1} weak_message2:{a:1}`,
|
|
wantErr: true, // weak_message2 is unknown since the package containing it is not imported
|
|
skip: !flags.ProtoLegacy,
|
|
}}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
if tt.skip {
|
|
continue
|
|
}
|
|
t.Run(tt.desc, func(t *testing.T) {
|
|
err := tt.umo.Unmarshal([]byte(tt.inputText), tt.inputMessage)
|
|
if err != nil && !tt.wantErr {
|
|
t.Errorf("Unmarshal() returned error: %v\n\n", err)
|
|
}
|
|
if err == nil && tt.wantErr {
|
|
t.Error("Unmarshal() got nil error, want error\n\n")
|
|
}
|
|
if tt.wantMessage != nil && !proto.Equal(tt.inputMessage, tt.wantMessage) {
|
|
t.Errorf("Unmarshal()\n<got>\n%v\n<want>\n%v\n", tt.inputMessage, tt.wantMessage)
|
|
}
|
|
})
|
|
}
|
|
}
|