Server : LiteSpeed System : Linux in-mum-web1112.main-hosting.eu 4.18.0-553.34.1.lve.el8.x86_64 #1 SMP Thu Jan 9 16:30:32 UTC 2025 x86_64 User : u451330669 ( 451330669) PHP Version : 8.2.27 Disable Function : NONE Directory : /opt/go/pkg/mod/google.golang.org/protobuf@v1.30.0/proto/ |
// Copyright 2019 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 proto_test
import (
"fmt"
"reflect"
"sync"
"testing"
"github.com/google/go-cmp/cmp"
"google.golang.org/protobuf/encoding/prototext"
"google.golang.org/protobuf/internal/protobuild"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/testing/protocmp"
"google.golang.org/protobuf/testing/protopack"
"google.golang.org/protobuf/types/dynamicpb"
legacypb "google.golang.org/protobuf/internal/testprotos/legacy"
testpb "google.golang.org/protobuf/internal/testprotos/test"
test3pb "google.golang.org/protobuf/internal/testprotos/test3"
)
type testMerge struct {
desc string
dst protobuild.Message
src protobuild.Message
want protobuild.Message // if dst and want are nil, want = src
types []proto.Message
}
var testMerges = []testMerge{{
desc: "clone a large message",
src: protobuild.Message{
"optional_int32": 1001,
"optional_int64": 1002,
"optional_uint32": 1003,
"optional_uint64": 1004,
"optional_sint32": 1005,
"optional_sint64": 1006,
"optional_fixed32": 1007,
"optional_fixed64": 1008,
"optional_sfixed32": 1009,
"optional_sfixed64": 1010,
"optional_float": 1011.5,
"optional_double": 1012.5,
"optional_bool": true,
"optional_string": "string",
"optional_bytes": []byte("bytes"),
"optional_nested_enum": 1,
"optional_nested_message": protobuild.Message{
"a": 100,
},
"repeated_int32": []int32{1001, 2001},
"repeated_int64": []int64{1002, 2002},
"repeated_uint32": []uint32{1003, 2003},
"repeated_uint64": []uint64{1004, 2004},
"repeated_sint32": []int32{1005, 2005},
"repeated_sint64": []int64{1006, 2006},
"repeated_fixed32": []uint32{1007, 2007},
"repeated_fixed64": []uint64{1008, 2008},
"repeated_sfixed32": []int32{1009, 2009},
"repeated_sfixed64": []int64{1010, 2010},
"repeated_float": []float32{1011.5, 2011.5},
"repeated_double": []float64{1012.5, 2012.5},
"repeated_bool": []bool{true, false},
"repeated_string": []string{"foo", "bar"},
"repeated_bytes": []string{"FOO", "BAR"},
"repeated_nested_enum": []string{"FOO", "BAR"},
"repeated_nested_message": []protobuild.Message{
{"a": 200},
{"a": 300},
},
},
}, {
desc: "clone maps",
src: protobuild.Message{
"map_int32_int32": map[int32]int32{1056: 1156, 2056: 2156},
"map_int64_int64": map[int64]int64{1057: 1157, 2057: 2157},
"map_uint32_uint32": map[uint32]uint32{1058: 1158, 2058: 2158},
"map_uint64_uint64": map[uint64]uint64{1059: 1159, 2059: 2159},
"map_sint32_sint32": map[int32]int32{1060: 1160, 2060: 2160},
"map_sint64_sint64": map[int64]int64{1061: 1161, 2061: 2161},
"map_fixed32_fixed32": map[uint32]uint32{1062: 1162, 2062: 2162},
"map_fixed64_fixed64": map[uint64]uint64{1063: 1163, 2063: 2163},
"map_sfixed32_sfixed32": map[int32]int32{1064: 1164, 2064: 2164},
"map_sfixed64_sfixed64": map[int64]int64{1065: 1165, 2065: 2165},
"map_int32_float": map[int32]float32{1066: 1166.5, 2066: 2166.5},
"map_int32_double": map[int32]float64{1067: 1167.5, 2067: 2167.5},
"map_bool_bool": map[bool]bool{true: false, false: true},
"map_string_string": map[string]string{"69.1.key": "69.1.val", "69.2.key": "69.2.val"},
"map_string_bytes": map[string][]byte{"70.1.key": []byte("70.1.val"), "70.2.key": []byte("70.2.val")},
"map_string_nested_message": map[string]protobuild.Message{
"71.1.key": {"a": 1171},
"71.2.key": {"a": 2171},
},
"map_string_nested_enum": map[string]string{"73.1.key": "FOO", "73.2.key": "BAR"},
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof uint32",
src: protobuild.Message{
"oneof_uint32": 1111,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof string",
src: protobuild.Message{
"oneof_string": "string",
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof bytes",
src: protobuild.Message{
"oneof_bytes": "bytes",
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof bool",
src: protobuild.Message{
"oneof_bool": true,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof uint64",
src: protobuild.Message{
"oneof_uint64": 100,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof float",
src: protobuild.Message{
"oneof_float": 100,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof double",
src: protobuild.Message{
"oneof_double": 1111,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof enum",
src: protobuild.Message{
"oneof_enum": 1,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof message",
src: protobuild.Message{
"oneof_nested_message": protobuild.Message{
"a": 1,
},
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "clone oneof group",
src: protobuild.Message{
"oneofgroup": protobuild.Message{
"a": 1,
},
},
types: []proto.Message{&testpb.TestAllTypes{}},
}, {
desc: "merge bytes",
dst: protobuild.Message{
"optional_bytes": []byte{1, 2, 3},
"repeated_bytes": [][]byte{{1, 2}, {3, 4}},
"map_string_bytes": map[string][]byte{"alpha": {1, 2, 3}},
},
src: protobuild.Message{
"optional_bytes": []byte{4, 5, 6},
"repeated_bytes": [][]byte{{5, 6}, {7, 8}},
"map_string_bytes": map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
},
want: protobuild.Message{
"optional_bytes": []byte{4, 5, 6},
"repeated_bytes": [][]byte{{1, 2}, {3, 4}, {5, 6}, {7, 8}},
"map_string_bytes": map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "merge singular fields",
dst: protobuild.Message{
"optional_int32": 1,
"optional_int64": 1,
"optional_uint32": 1,
"optional_uint64": 1,
"optional_sint32": 1,
"optional_sint64": 1,
"optional_fixed32": 1,
"optional_fixed64": 1,
"optional_sfixed32": 1,
"optional_sfixed64": 1,
"optional_float": 1,
"optional_double": 1,
"optional_bool": false,
"optional_string": "1",
"optional_bytes": "1",
"optional_nested_enum": 1,
"optional_nested_message": protobuild.Message{
"a": 1,
"corecursive": protobuild.Message{
"optional_int64": 1,
},
},
},
src: protobuild.Message{
"optional_int32": 2,
"optional_int64": 2,
"optional_uint32": 2,
"optional_uint64": 2,
"optional_sint32": 2,
"optional_sint64": 2,
"optional_fixed32": 2,
"optional_fixed64": 2,
"optional_sfixed32": 2,
"optional_sfixed64": 2,
"optional_float": 2,
"optional_double": 2,
"optional_bool": true,
"optional_string": "2",
"optional_bytes": "2",
"optional_nested_enum": 2,
"optional_nested_message": protobuild.Message{
"a": 2,
"corecursive": protobuild.Message{
"optional_int64": 2,
},
},
},
want: protobuild.Message{
"optional_int32": 2,
"optional_int64": 2,
"optional_uint32": 2,
"optional_uint64": 2,
"optional_sint32": 2,
"optional_sint64": 2,
"optional_fixed32": 2,
"optional_fixed64": 2,
"optional_sfixed32": 2,
"optional_sfixed64": 2,
"optional_float": 2,
"optional_double": 2,
"optional_bool": true,
"optional_string": "2",
"optional_bytes": "2",
"optional_nested_enum": 2,
"optional_nested_message": protobuild.Message{
"a": 2,
"corecursive": protobuild.Message{
"optional_int64": 2,
},
},
},
}, {
desc: "no merge of empty singular fields",
dst: protobuild.Message{
"optional_int32": 1,
"optional_int64": 1,
"optional_uint32": 1,
"optional_uint64": 1,
"optional_sint32": 1,
"optional_sint64": 1,
"optional_fixed32": 1,
"optional_fixed64": 1,
"optional_sfixed32": 1,
"optional_sfixed64": 1,
"optional_float": 1,
"optional_double": 1,
"optional_bool": false,
"optional_string": "1",
"optional_bytes": "1",
"optional_nested_enum": 1,
"optional_nested_message": protobuild.Message{
"a": 1,
"corecursive": protobuild.Message{
"optional_int64": 1,
},
},
},
src: protobuild.Message{
"optional_nested_message": protobuild.Message{
"a": 1,
"corecursive": protobuild.Message{
"optional_int32": 2,
},
},
},
want: protobuild.Message{
"optional_int32": 1,
"optional_int64": 1,
"optional_uint32": 1,
"optional_uint64": 1,
"optional_sint32": 1,
"optional_sint64": 1,
"optional_fixed32": 1,
"optional_fixed64": 1,
"optional_sfixed32": 1,
"optional_sfixed64": 1,
"optional_float": 1,
"optional_double": 1,
"optional_bool": false,
"optional_string": "1",
"optional_bytes": "1",
"optional_nested_enum": 1,
"optional_nested_message": protobuild.Message{
"a": 1,
"corecursive": protobuild.Message{
"optional_int32": 2,
"optional_int64": 1,
},
},
},
}, {
desc: "merge list fields",
dst: protobuild.Message{
"repeated_int32": []int32{1, 2, 3},
"repeated_int64": []int64{1, 2, 3},
"repeated_uint32": []uint32{1, 2, 3},
"repeated_uint64": []uint64{1, 2, 3},
"repeated_sint32": []int32{1, 2, 3},
"repeated_sint64": []int64{1, 2, 3},
"repeated_fixed32": []uint32{1, 2, 3},
"repeated_fixed64": []uint64{1, 2, 3},
"repeated_sfixed32": []int32{1, 2, 3},
"repeated_sfixed64": []int64{1, 2, 3},
"repeated_float": []float32{1, 2, 3},
"repeated_double": []float64{1, 2, 3},
"repeated_bool": []bool{true},
"repeated_string": []string{"a", "b", "c"},
"repeated_bytes": []string{"a", "b", "c"},
"repeated_nested_enum": []int{1, 2, 3},
"repeated_nested_message": []protobuild.Message{
{"a": 100},
{"a": 200},
},
},
src: protobuild.Message{
"repeated_int32": []int32{4, 5, 6},
"repeated_int64": []int64{4, 5, 6},
"repeated_uint32": []uint32{4, 5, 6},
"repeated_uint64": []uint64{4, 5, 6},
"repeated_sint32": []int32{4, 5, 6},
"repeated_sint64": []int64{4, 5, 6},
"repeated_fixed32": []uint32{4, 5, 6},
"repeated_fixed64": []uint64{4, 5, 6},
"repeated_sfixed32": []int32{4, 5, 6},
"repeated_sfixed64": []int64{4, 5, 6},
"repeated_float": []float32{4, 5, 6},
"repeated_double": []float64{4, 5, 6},
"repeated_bool": []bool{false},
"repeated_string": []string{"d", "e", "f"},
"repeated_bytes": []string{"d", "e", "f"},
"repeated_nested_enum": []int{4, 5, 6},
"repeated_nested_message": []protobuild.Message{
{"a": 300},
{"a": 400},
},
},
want: protobuild.Message{
"repeated_int32": []int32{1, 2, 3, 4, 5, 6},
"repeated_int64": []int64{1, 2, 3, 4, 5, 6},
"repeated_uint32": []uint32{1, 2, 3, 4, 5, 6},
"repeated_uint64": []uint64{1, 2, 3, 4, 5, 6},
"repeated_sint32": []int32{1, 2, 3, 4, 5, 6},
"repeated_sint64": []int64{1, 2, 3, 4, 5, 6},
"repeated_fixed32": []uint32{1, 2, 3, 4, 5, 6},
"repeated_fixed64": []uint64{1, 2, 3, 4, 5, 6},
"repeated_sfixed32": []int32{1, 2, 3, 4, 5, 6},
"repeated_sfixed64": []int64{1, 2, 3, 4, 5, 6},
"repeated_float": []float32{1, 2, 3, 4, 5, 6},
"repeated_double": []float64{1, 2, 3, 4, 5, 6},
"repeated_bool": []bool{true, false},
"repeated_string": []string{"a", "b", "c", "d", "e", "f"},
"repeated_bytes": []string{"a", "b", "c", "d", "e", "f"},
"repeated_nested_enum": []int{1, 2, 3, 4, 5, 6},
"repeated_nested_message": []protobuild.Message{
{"a": 100},
{"a": 200},
{"a": 300},
{"a": 400},
},
},
}, {
desc: "merge map fields",
dst: protobuild.Message{
"map_int32_int32": map[int]int{1: 1, 3: 1},
"map_int64_int64": map[int]int{1: 1, 3: 1},
"map_uint32_uint32": map[int]int{1: 1, 3: 1},
"map_uint64_uint64": map[int]int{1: 1, 3: 1},
"map_sint32_sint32": map[int]int{1: 1, 3: 1},
"map_sint64_sint64": map[int]int{1: 1, 3: 1},
"map_fixed32_fixed32": map[int]int{1: 1, 3: 1},
"map_fixed64_fixed64": map[int]int{1: 1, 3: 1},
"map_sfixed32_sfixed32": map[int]int{1: 1, 3: 1},
"map_sfixed64_sfixed64": map[int]int{1: 1, 3: 1},
"map_int32_float": map[int]int{1: 1, 3: 1},
"map_int32_double": map[int]int{1: 1, 3: 1},
"map_bool_bool": map[bool]bool{true: true},
"map_string_string": map[string]string{"a": "1", "ab": "1"},
"map_string_bytes": map[string]string{"a": "1", "ab": "1"},
"map_string_nested_message": map[string]protobuild.Message{
"a": {"a": 1},
"ab": {
"a": 1,
"corecursive": protobuild.Message{
"map_int32_int32": map[int]int{1: 1, 3: 1},
},
},
},
"map_string_nested_enum": map[string]int{"a": 1, "ab": 1},
},
src: protobuild.Message{
"map_int32_int32": map[int]int{2: 2, 3: 2},
"map_int64_int64": map[int]int{2: 2, 3: 2},
"map_uint32_uint32": map[int]int{2: 2, 3: 2},
"map_uint64_uint64": map[int]int{2: 2, 3: 2},
"map_sint32_sint32": map[int]int{2: 2, 3: 2},
"map_sint64_sint64": map[int]int{2: 2, 3: 2},
"map_fixed32_fixed32": map[int]int{2: 2, 3: 2},
"map_fixed64_fixed64": map[int]int{2: 2, 3: 2},
"map_sfixed32_sfixed32": map[int]int{2: 2, 3: 2},
"map_sfixed64_sfixed64": map[int]int{2: 2, 3: 2},
"map_int32_float": map[int]int{2: 2, 3: 2},
"map_int32_double": map[int]int{2: 2, 3: 2},
"map_bool_bool": map[bool]bool{false: false},
"map_string_string": map[string]string{"b": "2", "ab": "2"},
"map_string_bytes": map[string]string{"b": "2", "ab": "2"},
"map_string_nested_message": map[string]protobuild.Message{
"b": {"a": 2},
"ab": {
"a": 2,
"corecursive": protobuild.Message{
"map_int32_int32": map[int]int{2: 2, 3: 2},
},
},
},
"map_string_nested_enum": map[string]int{"b": 2, "ab": 2},
},
want: protobuild.Message{
"map_int32_int32": map[int]int{1: 1, 2: 2, 3: 2},
"map_int64_int64": map[int]int{1: 1, 2: 2, 3: 2},
"map_uint32_uint32": map[int]int{1: 1, 2: 2, 3: 2},
"map_uint64_uint64": map[int]int{1: 1, 2: 2, 3: 2},
"map_sint32_sint32": map[int]int{1: 1, 2: 2, 3: 2},
"map_sint64_sint64": map[int]int{1: 1, 2: 2, 3: 2},
"map_fixed32_fixed32": map[int]int{1: 1, 2: 2, 3: 2},
"map_fixed64_fixed64": map[int]int{1: 1, 2: 2, 3: 2},
"map_sfixed32_sfixed32": map[int]int{1: 1, 2: 2, 3: 2},
"map_sfixed64_sfixed64": map[int]int{1: 1, 2: 2, 3: 2},
"map_int32_float": map[int]int{1: 1, 2: 2, 3: 2},
"map_int32_double": map[int]int{1: 1, 2: 2, 3: 2},
"map_bool_bool": map[bool]bool{true: true, false: false},
"map_string_string": map[string]string{"a": "1", "b": "2", "ab": "2"},
"map_string_bytes": map[string]string{"a": "1", "b": "2", "ab": "2"},
"map_string_nested_message": map[string]protobuild.Message{
"a": {"a": 1},
"b": {"a": 2},
"ab": {
"a": 2,
"corecursive": protobuild.Message{
// The map item "ab" was entirely replaced, so
// this does not contain 1:1 from dst.
"map_int32_int32": map[int]int{2: 2, 3: 2},
},
},
},
"map_string_nested_enum": map[string]int{"a": 1, "b": 2, "ab": 2},
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "merge oneof message fields",
dst: protobuild.Message{
"oneof_nested_message": protobuild.Message{
"a": 100,
},
},
src: protobuild.Message{
"oneof_nested_message": protobuild.Message{
"corecursive": protobuild.Message{
"optional_int64": 1000,
},
},
},
want: protobuild.Message{
"oneof_nested_message": protobuild.Message{
"a": 100,
"corecursive": protobuild.Message{
"optional_int64": 1000,
},
},
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "merge oneof scalar fields",
dst: protobuild.Message{
"oneof_uint32": 100,
},
src: protobuild.Message{
"oneof_float": 3.14152,
},
want: protobuild.Message{
"oneof_float": 3.14152,
},
types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
}, {
desc: "merge unknown fields",
dst: protobuild.Message{
protobuild.Unknown: protopack.Message{
protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
}.Marshal(),
},
src: protobuild.Message{
protobuild.Unknown: protopack.Message{
protopack.Tag{Number: 500000, Type: protopack.VarintType}, protopack.Svarint(-50),
}.Marshal(),
},
want: protobuild.Message{
protobuild.Unknown: protopack.Message{
protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
protopack.Tag{Number: 500000, Type: protopack.VarintType}, protopack.Svarint(-50),
}.Marshal(),
},
}, {
desc: "clone legacy message",
src: protobuild.Message{"f1": protobuild.Message{
"optional_int32": 1,
"optional_int64": 1,
"optional_uint32": 1,
"optional_uint64": 1,
"optional_sint32": 1,
"optional_sint64": 1,
"optional_fixed32": 1,
"optional_fixed64": 1,
"optional_sfixed32": 1,
"optional_sfixed64": 1,
"optional_float": 1,
"optional_double": 1,
"optional_bool": true,
"optional_string": "string",
"optional_bytes": "bytes",
"optional_sibling_enum": 1,
"optional_sibling_message": protobuild.Message{
"f1": "value",
},
"repeated_int32": []int32{1},
"repeated_int64": []int64{1},
"repeated_uint32": []uint32{1},
"repeated_uint64": []uint64{1},
"repeated_sint32": []int32{1},
"repeated_sint64": []int64{1},
"repeated_fixed32": []uint32{1},
"repeated_fixed64": []uint64{1},
"repeated_sfixed32": []int32{1},
"repeated_sfixed64": []int64{1},
"repeated_float": []float32{1},
"repeated_double": []float64{1},
"repeated_bool": []bool{true},
"repeated_string": []string{"string"},
"repeated_bytes": []string{"bytes"},
"repeated_sibling_enum": []int{1},
"repeated_sibling_message": []protobuild.Message{
{"f1": "1"},
},
"map_bool_int32": map[bool]int{true: 1},
"map_bool_int64": map[bool]int{true: 1},
"map_bool_uint32": map[bool]int{true: 1},
"map_bool_uint64": map[bool]int{true: 1},
"map_bool_sint32": map[bool]int{true: 1},
"map_bool_sint64": map[bool]int{true: 1},
"map_bool_fixed32": map[bool]int{true: 1},
"map_bool_fixed64": map[bool]int{true: 1},
"map_bool_sfixed32": map[bool]int{true: 1},
"map_bool_sfixed64": map[bool]int{true: 1},
"map_bool_float": map[bool]int{true: 1},
"map_bool_double": map[bool]int{true: 1},
"map_bool_bool": map[bool]bool{true: false},
"map_bool_string": map[bool]string{true: "1"},
"map_bool_bytes": map[bool]string{true: "1"},
"map_bool_sibling_message": map[bool]protobuild.Message{
true: {"f1": "1"},
},
"map_bool_sibling_enum": map[bool]int{true: 1},
"oneof_sibling_message": protobuild.Message{
"f1": "1",
},
}},
types: []proto.Message{&legacypb.Legacy{}},
}}
func TestMerge(t *testing.T) {
for _, tt := range testMerges {
for _, mt := range templateMessages(tt.types...) {
t.Run(fmt.Sprintf("%s (%v)", tt.desc, mt.Descriptor().FullName()), func(t *testing.T) {
dst := mt.New().Interface()
tt.dst.Build(dst.ProtoReflect())
src := mt.New().Interface()
tt.src.Build(src.ProtoReflect())
want := mt.New().Interface()
if tt.dst == nil && tt.want == nil {
tt.src.Build(want.ProtoReflect())
} else {
tt.want.Build(want.ProtoReflect())
}
// Merge should be semantically equivalent to unmarshaling the
// encoded form of src into the current dst.
b1, err := proto.MarshalOptions{AllowPartial: true}.Marshal(dst)
if err != nil {
t.Fatalf("Marshal(dst) error: %v", err)
}
b2, err := proto.MarshalOptions{AllowPartial: true}.Marshal(src)
if err != nil {
t.Fatalf("Marshal(src) error: %v", err)
}
unmarshaled := dst.ProtoReflect().New().Interface()
err = proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(append(b1, b2...), unmarshaled)
if err != nil {
t.Fatalf("Unmarshal() error: %v", err)
}
if !proto.Equal(unmarshaled, want) {
t.Fatalf("Unmarshal(Marshal(dst)+Marshal(src)) mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", unmarshaled, want, cmp.Diff(want, unmarshaled, protocmp.Transform()))
}
// Test heterogeneous MessageTypes by merging into a
// dynamic message.
ddst := dynamicpb.NewMessage(mt.Descriptor())
tt.dst.Build(ddst.ProtoReflect())
proto.Merge(ddst, src)
if !proto.Equal(ddst, want) {
t.Fatalf("Merge() into dynamic message mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", ddst, want, cmp.Diff(want, ddst, protocmp.Transform()))
}
proto.Merge(dst, src)
if !proto.Equal(dst, want) {
t.Fatalf("Merge() mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", dst, want, cmp.Diff(want, dst, protocmp.Transform()))
}
mutateValue(protoreflect.ValueOfMessage(src.ProtoReflect()))
if !proto.Equal(dst, want) {
t.Fatalf("mutation observed after modifying source:\n got %v\nwant %v\ndiff (-want,+got):\n%v", dst, want, cmp.Diff(want, dst, protocmp.Transform()))
}
})
}
}
}
func TestMergeFromNil(t *testing.T) {
dst := &testpb.TestAllTypes{}
proto.Merge(dst, (*testpb.TestAllTypes)(nil))
if !proto.Equal(dst, &testpb.TestAllTypes{}) {
t.Errorf("destination should be empty after merging from nil message; got:\n%v", prototext.Format(dst))
}
}
// TestMergeAberrant tests inputs that are beyond the protobuf data model.
// Just because there is a test for the current behavior does not mean that
// this will behave the same way in the future.
func TestMergeAberrant(t *testing.T) {
tests := []struct {
label string
dst proto.Message
src proto.Message
check func(proto.Message) bool
}{{
label: "Proto2EmptyBytes",
dst: &testpb.TestAllTypes{OptionalBytes: nil},
src: &testpb.TestAllTypes{OptionalBytes: []byte{}},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).OptionalBytes != nil
},
}, {
label: "Proto3EmptyBytes",
dst: &test3pb.TestAllTypes{SingularBytes: nil},
src: &test3pb.TestAllTypes{SingularBytes: []byte{}},
check: func(m proto.Message) bool {
return m.(*test3pb.TestAllTypes).SingularBytes == nil
},
}, {
label: "EmptyList",
dst: &testpb.TestAllTypes{RepeatedInt32: nil},
src: &testpb.TestAllTypes{RepeatedInt32: []int32{}},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).RepeatedInt32 == nil
},
}, {
label: "ListWithNilBytes",
dst: &testpb.TestAllTypes{RepeatedBytes: nil},
src: &testpb.TestAllTypes{RepeatedBytes: [][]byte{nil}},
check: func(m proto.Message) bool {
return reflect.DeepEqual(m.(*testpb.TestAllTypes).RepeatedBytes, [][]byte{{}})
},
}, {
label: "ListWithEmptyBytes",
dst: &testpb.TestAllTypes{RepeatedBytes: nil},
src: &testpb.TestAllTypes{RepeatedBytes: [][]byte{{}}},
check: func(m proto.Message) bool {
return reflect.DeepEqual(m.(*testpb.TestAllTypes).RepeatedBytes, [][]byte{{}})
},
}, {
label: "ListWithNilMessage",
dst: &testpb.TestAllTypes{RepeatedNestedMessage: nil},
src: &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{nil}},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).RepeatedNestedMessage[0] != nil
},
}, {
label: "EmptyMap",
dst: &testpb.TestAllTypes{MapStringString: nil},
src: &testpb.TestAllTypes{MapStringString: map[string]string{}},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).MapStringString == nil
},
}, {
label: "MapWithNilBytes",
dst: &testpb.TestAllTypes{MapStringBytes: nil},
src: &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"k": nil}},
check: func(m proto.Message) bool {
return reflect.DeepEqual(m.(*testpb.TestAllTypes).MapStringBytes, map[string][]byte{"k": {}})
},
}, {
label: "MapWithEmptyBytes",
dst: &testpb.TestAllTypes{MapStringBytes: nil},
src: &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"k": {}}},
check: func(m proto.Message) bool {
return reflect.DeepEqual(m.(*testpb.TestAllTypes).MapStringBytes, map[string][]byte{"k": {}})
},
}, {
label: "MapWithNilMessage",
dst: &testpb.TestAllTypes{MapStringNestedMessage: nil},
src: &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": nil}},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).MapStringNestedMessage["k"] != nil
},
}, {
label: "OneofWithTypedNilWrapper",
dst: &testpb.TestAllTypes{OneofField: nil},
src: &testpb.TestAllTypes{OneofField: (*testpb.TestAllTypes_OneofNestedMessage)(nil)},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).OneofField == nil
},
}, {
label: "OneofWithNilMessage",
dst: &testpb.TestAllTypes{OneofField: nil},
src: &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofNestedMessage{OneofNestedMessage: nil}},
check: func(m proto.Message) bool {
return m.(*testpb.TestAllTypes).OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage != nil
},
// TODO: extension, nil message
// TODO: repeated extension, nil
// TODO: extension bytes
// TODO: repeated extension, nil message
}}
for _, tt := range tests {
t.Run(tt.label, func(t *testing.T) {
var pass bool
func() {
defer func() { recover() }()
proto.Merge(tt.dst, tt.src)
pass = tt.check(tt.dst)
}()
if !pass {
t.Error("check failed")
}
})
}
}
func TestMergeRace(t *testing.T) {
dst := new(testpb.TestAllTypes)
srcs := []*testpb.TestAllTypes{
{OptionalInt32: proto.Int32(1)},
{OptionalString: proto.String("hello")},
{RepeatedInt32: []int32{2, 3, 4}},
{RepeatedString: []string{"goodbye"}},
{MapStringString: map[string]string{"key": "value"}},
{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
A: proto.Int32(5),
}},
func() *testpb.TestAllTypes {
m := new(testpb.TestAllTypes)
m.ProtoReflect().SetUnknown(protopack.Message{
protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
}.Marshal())
return m
}(),
}
// It should be safe to concurrently merge non-overlapping fields.
var wg sync.WaitGroup
defer wg.Wait()
for _, src := range srcs {
wg.Add(1)
go func(src proto.Message) {
defer wg.Done()
proto.Merge(dst, src)
}(src)
}
}
func TestMergeSelf(t *testing.T) {
got := &testpb.TestAllTypes{
OptionalInt32: proto.Int32(1),
OptionalString: proto.String("hello"),
RepeatedInt32: []int32{2, 3, 4},
RepeatedString: []string{"goodbye"},
MapStringString: map[string]string{"key": "value"},
OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
A: proto.Int32(5),
},
}
got.ProtoReflect().SetUnknown(protopack.Message{
protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
}.Marshal())
proto.Merge(got, got)
// The main impact of merging to self is that repeated fields and
// unknown fields are doubled.
want := &testpb.TestAllTypes{
OptionalInt32: proto.Int32(1),
OptionalString: proto.String("hello"),
RepeatedInt32: []int32{2, 3, 4, 2, 3, 4},
RepeatedString: []string{"goodbye", "goodbye"},
MapStringString: map[string]string{"key": "value"},
OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
A: proto.Int32(5),
},
}
want.ProtoReflect().SetUnknown(protopack.Message{
protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Svarint(-5),
}.Marshal())
if !proto.Equal(got, want) {
t.Errorf("Equal mismatch:\ngot %v\nwant %v", got, want)
}
}
func TestClone(t *testing.T) {
want := &testpb.TestAllTypes{
OptionalInt32: proto.Int32(1),
}
got := proto.Clone(want).(*testpb.TestAllTypes)
if !proto.Equal(got, want) {
t.Errorf("Clone(src) != src:\n got %v\nwant %v", got, want)
}
}
// mutateValue changes a Value, returning a new value.
//
// For scalar values, it returns a value different from the input.
// For Message, List, and Map values, it mutates the input and returns it.
func mutateValue(v protoreflect.Value) protoreflect.Value {
switch v := v.Interface().(type) {
case bool:
return protoreflect.ValueOfBool(!v)
case protoreflect.EnumNumber:
return protoreflect.ValueOfEnum(v + 1)
case int32:
return protoreflect.ValueOfInt32(v + 1)
case int64:
return protoreflect.ValueOfInt64(v + 1)
case uint32:
return protoreflect.ValueOfUint32(v + 1)
case uint64:
return protoreflect.ValueOfUint64(v + 1)
case float32:
return protoreflect.ValueOfFloat32(v + 1)
case float64:
return protoreflect.ValueOfFloat64(v + 1)
case []byte:
for i := range v {
v[i]++
}
return protoreflect.ValueOfBytes(v)
case string:
return protoreflect.ValueOfString("_" + v)
case protoreflect.Message:
v.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
v.Set(fd, mutateValue(val))
return true
})
return protoreflect.ValueOfMessage(v)
case protoreflect.List:
for i := 0; i < v.Len(); i++ {
v.Set(i, mutateValue(v.Get(i)))
}
return protoreflect.ValueOfList(v)
case protoreflect.Map:
v.Range(func(mk protoreflect.MapKey, mv protoreflect.Value) bool {
v.Set(mk, mutateValue(mv))
return true
})
return protoreflect.ValueOfMap(v)
default:
panic(fmt.Sprintf("unknown value type %T", v))
}
}