1
2
3
4
5 package msgfmt_test
6
7 import (
8 "math"
9 "sync"
10 "testing"
11
12 "github.com/google/go-cmp/cmp"
13
14 "google.golang.org/protobuf/internal/detrand"
15 "google.golang.org/protobuf/internal/msgfmt"
16 "google.golang.org/protobuf/proto"
17 "google.golang.org/protobuf/testing/protocmp"
18 "google.golang.org/protobuf/testing/protopack"
19
20 testpb "google.golang.org/protobuf/internal/testprotos/test"
21 textpb "google.golang.org/protobuf/internal/testprotos/textpb2"
22 dynpb "google.golang.org/protobuf/types/dynamicpb"
23 anypb "google.golang.org/protobuf/types/known/anypb"
24 durpb "google.golang.org/protobuf/types/known/durationpb"
25 tspb "google.golang.org/protobuf/types/known/timestamppb"
26 wpb "google.golang.org/protobuf/types/known/wrapperspb"
27 )
28
29 func init() {
30 detrand.Disable()
31 }
32
33 func TestFormat(t *testing.T) {
34 optMsg := &testpb.TestAllTypes{
35 OptionalBool: proto.Bool(false),
36 OptionalInt32: proto.Int32(-32),
37 OptionalInt64: proto.Int64(-64),
38 OptionalUint32: proto.Uint32(32),
39 OptionalUint64: proto.Uint64(64),
40 OptionalFloat: proto.Float32(32.32),
41 OptionalDouble: proto.Float64(64.64),
42 OptionalString: proto.String("string"),
43 OptionalBytes: []byte("bytes"),
44 OptionalNestedEnum: testpb.TestAllTypes_NEG.Enum(),
45 OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{A: proto.Int32(5)},
46 }
47 repMsg := &testpb.TestAllTypes{
48 RepeatedBool: []bool{false, true},
49 RepeatedInt32: []int32{32, -32},
50 RepeatedInt64: []int64{64, -64},
51 RepeatedUint32: []uint32{0, 32},
52 RepeatedUint64: []uint64{0, 64},
53 RepeatedFloat: []float32{0, 32.32},
54 RepeatedDouble: []float64{0, 64.64},
55 RepeatedString: []string{"s1", "s2"},
56 RepeatedBytes: [][]byte{{1}, {2}},
57 RepeatedNestedEnum: []testpb.TestAllTypes_NestedEnum{
58 testpb.TestAllTypes_FOO,
59 testpb.TestAllTypes_BAR,
60 },
61 RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
62 {A: proto.Int32(5)},
63 {A: proto.Int32(-5)},
64 },
65 }
66 mapMsg := &testpb.TestAllTypes{
67 MapBoolBool: map[bool]bool{true: false},
68 MapInt32Int32: map[int32]int32{-32: 32},
69 MapInt64Int64: map[int64]int64{-64: 64},
70 MapUint32Uint32: map[uint32]uint32{0: 32},
71 MapUint64Uint64: map[uint64]uint64{0: 64},
72 MapInt32Float: map[int32]float32{32: 32.32},
73 MapInt32Double: map[int32]float64{64: 64.64},
74 MapStringString: map[string]string{"k": "v"},
75 MapStringBytes: map[string][]byte{"k": []byte("v")},
76 MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
77 "k": testpb.TestAllTypes_FOO,
78 },
79 MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
80 "k": {A: proto.Int32(5)},
81 },
82 }
83
84 tests := []struct {
85 in proto.Message
86 want string
87 }{{
88 in: optMsg,
89 want: `{optional_int32:-32, optional_int64:-64, optional_uint32:32, optional_uint64:64, optional_float:32.32, optional_double:64.64, optional_bool:false, optional_string:"string", optional_bytes:"bytes", optional_nested_message:{a:5}, optional_nested_enum:NEG}`,
90 }, {
91 in: repMsg,
92 want: `{repeated_int32:[32, -32], repeated_int64:[64, -64], repeated_uint32:[0, 32], repeated_uint64:[0, 64], repeated_float:[0, 32.32], repeated_double:[0, 64.64], repeated_bool:[false, true], repeated_string:["s1", "s2"], repeated_bytes:["\x01", "\x02"], repeated_nested_message:[{a:5}, {a:-5}], repeated_nested_enum:[FOO, BAR]}`,
93 }, {
94 in: mapMsg,
95 want: `{map_int32_int32:{-32:32}, map_int64_int64:{-64:64}, map_uint32_uint32:{0:32}, map_uint64_uint64:{0:64}, map_int32_float:{32:32.32}, map_int32_double:{64:64.64}, map_bool_bool:{true:false}, map_string_string:{"k":"v"}, map_string_bytes:{"k":"v"}, map_string_nested_message:{"k":{a:5}}, map_string_nested_enum:{"k":FOO}}`,
96 }, {
97 in: func() proto.Message {
98 m := &testpb.TestAllExtensions{}
99 proto.SetExtension(m, testpb.E_OptionalBool, bool(false))
100 proto.SetExtension(m, testpb.E_OptionalInt32, int32(-32))
101 proto.SetExtension(m, testpb.E_OptionalInt64, int64(-64))
102 proto.SetExtension(m, testpb.E_OptionalUint32, uint32(32))
103 proto.SetExtension(m, testpb.E_OptionalUint64, uint64(64))
104 proto.SetExtension(m, testpb.E_OptionalFloat, float32(32.32))
105 proto.SetExtension(m, testpb.E_OptionalDouble, float64(64.64))
106 proto.SetExtension(m, testpb.E_OptionalString, string("string"))
107 proto.SetExtension(m, testpb.E_OptionalBytes, []byte("bytes"))
108 proto.SetExtension(m, testpb.E_OptionalNestedEnum, testpb.TestAllTypes_NEG)
109 proto.SetExtension(m, testpb.E_OptionalNestedMessage, &testpb.TestAllExtensions_NestedMessage{A: proto.Int32(5)})
110 return m
111 }(),
112 want: `{[goproto.proto.test.optional_bool]:false, [goproto.proto.test.optional_bytes]:"bytes", [goproto.proto.test.optional_double]:64.64, [goproto.proto.test.optional_float]:32.32, [goproto.proto.test.optional_int32]:-32, [goproto.proto.test.optional_int64]:-64, [goproto.proto.test.optional_nested_enum]:NEG, [goproto.proto.test.optional_nested_message]:{a:5}, [goproto.proto.test.optional_string]:"string", [goproto.proto.test.optional_uint32]:32, [goproto.proto.test.optional_uint64]:64}`,
113 }, {
114 in: func() proto.Message {
115 m := &testpb.TestAllExtensions{}
116 proto.SetExtension(m, testpb.E_RepeatedBool, []bool{false, true})
117 proto.SetExtension(m, testpb.E_RepeatedInt32, []int32{32, -32})
118 proto.SetExtension(m, testpb.E_RepeatedInt64, []int64{64, -64})
119 proto.SetExtension(m, testpb.E_RepeatedUint32, []uint32{0, 32})
120 proto.SetExtension(m, testpb.E_RepeatedUint64, []uint64{0, 64})
121 proto.SetExtension(m, testpb.E_RepeatedFloat, []float32{0, 32.32})
122 proto.SetExtension(m, testpb.E_RepeatedDouble, []float64{0, 64.64})
123 proto.SetExtension(m, testpb.E_RepeatedString, []string{"s1", "s2"})
124 proto.SetExtension(m, testpb.E_RepeatedBytes, [][]byte{{1}, {2}})
125 proto.SetExtension(m, testpb.E_RepeatedNestedEnum, []testpb.TestAllTypes_NestedEnum{
126 testpb.TestAllTypes_FOO,
127 testpb.TestAllTypes_BAR,
128 })
129 proto.SetExtension(m, testpb.E_RepeatedNestedMessage, []*testpb.TestAllExtensions_NestedMessage{
130 {A: proto.Int32(5)},
131 {A: proto.Int32(-5)},
132 })
133 return m
134 }(),
135 want: `{[goproto.proto.test.repeated_bool]:[false, true], [goproto.proto.test.repeated_bytes]:["\x01", "\x02"], [goproto.proto.test.repeated_double]:[0, 64.64], [goproto.proto.test.repeated_float]:[0, 32.32], [goproto.proto.test.repeated_int32]:[32, -32], [goproto.proto.test.repeated_int64]:[64, -64], [goproto.proto.test.repeated_nested_enum]:[FOO, BAR], [goproto.proto.test.repeated_nested_message]:[{a:5}, {a:-5}], [goproto.proto.test.repeated_string]:["s1", "s2"], [goproto.proto.test.repeated_uint32]:[0, 32], [goproto.proto.test.repeated_uint64]:[0, 64]}`,
136 }, {
137 in: func() proto.Message {
138 m := &testpb.TestAllTypes{}
139 m.ProtoReflect().SetUnknown(protopack.Message{
140 protopack.Tag{Number: 50000, Type: protopack.VarintType}, protopack.Uvarint(100),
141 protopack.Tag{Number: 50001, Type: protopack.Fixed32Type}, protopack.Uint32(200),
142 protopack.Tag{Number: 50002, Type: protopack.Fixed64Type}, protopack.Uint64(300),
143 protopack.Tag{Number: 50003, Type: protopack.BytesType}, protopack.String("hello"),
144 protopack.Message{
145 protopack.Tag{Number: 50004, Type: protopack.StartGroupType},
146 protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
147 protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
148 protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
149 protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
150 protopack.Message{
151 protopack.Tag{Number: 1, Type: protopack.StartGroupType},
152 protopack.Tag{Number: 1, Type: protopack.VarintType}, protopack.Uvarint(100),
153 protopack.Tag{Number: 1, Type: protopack.Fixed32Type}, protopack.Uint32(200),
154 protopack.Tag{Number: 1, Type: protopack.Fixed64Type}, protopack.Uint64(300),
155 protopack.Tag{Number: 1, Type: protopack.BytesType}, protopack.String("hello"),
156 protopack.Tag{Number: 1, Type: protopack.EndGroupType},
157 },
158 protopack.Tag{Number: 50004, Type: protopack.EndGroupType},
159 },
160 }.Marshal())
161 return m
162 }(),
163 want: `{50000:100, 50001:0x000000c8, 50002:0x000000000000012c, 50003:"hello", 50004:{1:[100, 0x000000c8, 0x000000000000012c, "hello", {1:[100, 0x000000c8, 0x000000000000012c, "hello"]}]}}`,
164 }, {
165 in: &textpb.KnownTypes{
166 OptAny: &anypb.Any{
167 TypeUrl: "google.golang.org/goproto.proto.test.TestAllTypes",
168 Value: func() []byte {
169 b1, _ := proto.MarshalOptions{Deterministic: true}.Marshal(optMsg)
170 b2, _ := proto.MarshalOptions{Deterministic: true}.Marshal(repMsg)
171 b3, _ := proto.MarshalOptions{Deterministic: true}.Marshal(mapMsg)
172 return append(append(append([]byte(nil), b1...), b2...), b3...)
173 }(),
174 },
175 },
176 want: `{opt_any:{[google.golang.org/goproto.proto.test.TestAllTypes]:{optional_int32:-32, optional_int64:-64, optional_uint32:32, optional_uint64:64, optional_float:32.32, optional_double:64.64, optional_bool:false, optional_string:"string", optional_bytes:"bytes", optional_nested_message:{a:5}, optional_nested_enum:NEG, repeated_int32:[32, -32], repeated_int64:[64, -64], repeated_uint32:[0, 32], repeated_uint64:[0, 64], repeated_float:[0, 32.32], repeated_double:[0, 64.64], repeated_bool:[false, true], repeated_string:["s1", "s2"], repeated_bytes:["\x01", "\x02"], repeated_nested_message:[{a:5}, {a:-5}], repeated_nested_enum:[FOO, BAR], map_int32_int32:{-32:32}, map_int64_int64:{-64:64}, map_uint32_uint32:{0:32}, map_uint64_uint64:{0:64}, map_int32_float:{32:32.32}, map_int32_double:{64:64.64}, map_bool_bool:{true:false}, map_string_string:{"k":"v"}, map_string_bytes:{"k":"v"}, map_string_nested_message:{"k":{a:5}}, map_string_nested_enum:{"k":FOO}}}}`,
177 }, {
178 in: &textpb.KnownTypes{
179 OptTimestamp: &tspb.Timestamp{Seconds: math.MinInt64, Nanos: math.MaxInt32},
180 },
181 want: `{opt_timestamp:{seconds:-9223372036854775808, nanos:2147483647}}`,
182 }, {
183 in: &textpb.KnownTypes{
184 OptTimestamp: &tspb.Timestamp{Seconds: 1257894123, Nanos: 456789},
185 },
186 want: `{opt_timestamp:2009-11-10T23:02:03.000456789Z}`,
187 }, {
188 in: &textpb.KnownTypes{
189 OptDuration: &durpb.Duration{Seconds: math.MinInt64, Nanos: math.MaxInt32},
190 },
191 want: `{opt_duration:{seconds:-9223372036854775808, nanos:2147483647}}`,
192 }, {
193 in: &textpb.KnownTypes{
194 OptDuration: &durpb.Duration{Seconds: +1257894123, Nanos: +456789},
195 },
196 want: `{opt_duration:1257894123.000456789s}`,
197 }, {
198 in: &textpb.KnownTypes{
199 OptDuration: &durpb.Duration{Seconds: -1257894123, Nanos: -456789},
200 },
201 want: `{opt_duration:-1257894123.000456789s}`,
202 }, {
203 in: &textpb.KnownTypes{
204 OptDuration: &durpb.Duration{Seconds: 0, Nanos: -1},
205 },
206 want: `{opt_duration:-0.000000001s}`,
207 }, {
208 in: &textpb.KnownTypes{
209 OptBool: &wpb.BoolValue{},
210 OptInt32: &wpb.Int32Value{},
211 OptInt64: &wpb.Int64Value{},
212 OptUint32: &wpb.UInt32Value{},
213 OptUint64: &wpb.UInt64Value{},
214 OptFloat: &wpb.FloatValue{},
215 OptDouble: &wpb.DoubleValue{},
216 OptString: &wpb.StringValue{},
217 OptBytes: &wpb.BytesValue{},
218 },
219 want: `{opt_bool:false, opt_int32:0, opt_int64:0, opt_uint32:0, opt_uint64:0, opt_float:0, opt_double:0, opt_string:"", opt_bytes:""}`,
220 }}
221 for _, tt := range tests {
222 t.Run("Generated", func(t *testing.T) {
223 got := msgfmt.Format(tt.in)
224 if diff := cmp.Diff(tt.want, got); diff != "" {
225 t.Errorf("Format() mismatch (-want +got):\n%v", diff)
226 }
227 })
228 t.Run("dynamicpb.Message", func(t *testing.T) {
229 m := dynpb.NewMessage(tt.in.ProtoReflect().Descriptor())
230 proto.Merge(m, tt.in)
231 got := msgfmt.Format(m)
232 if diff := cmp.Diff(tt.want, got); diff != "" {
233 t.Errorf("Format() mismatch (-want +got):\n%v", diff)
234 }
235 })
236 t.Run("protocmp.Message", func(t *testing.T) {
237
238
239 var m proto.Message
240 var once sync.Once
241 cmp.Equal(tt.in, tt.in, protocmp.Transform(), cmp.FilterPath(func(p cmp.Path) bool {
242 if v, _ := p.Index(1).Values(); v.IsValid() {
243 once.Do(func() { m = v.Interface().(protocmp.Message) })
244 }
245 return false
246 }, cmp.Ignore()))
247
248 got := msgfmt.Format(m)
249 if diff := cmp.Diff(tt.want, got); diff != "" {
250 t.Errorf("Format() mismatch (-want +got):\n%v", diff)
251 }
252 })
253 }
254 }
255
View as plain text