Damien Neil | c37adef | 2019-04-01 13:49:56 -0700 | [diff] [blame] | 1 | // Copyright 2019 The Go Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style |
| 3 | // license that can be found in the LICENSE file. |
| 4 | |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 5 | package proto_test |
| 6 | |
| 7 | import ( |
| 8 | "bytes" |
| 9 | "fmt" |
Damien Neil | 01c0e8d | 2019-11-12 12:33:12 -0800 | [diff] [blame^] | 10 | "reflect" |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 11 | "testing" |
| 12 | |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 13 | "github.com/google/go-cmp/cmp" |
Damien Neil | 01c0e8d | 2019-11-12 12:33:12 -0800 | [diff] [blame^] | 14 | "google.golang.org/protobuf/internal/encoding/wire" |
Joe Tsai | c51e2e0 | 2019-07-13 00:44:41 -0700 | [diff] [blame] | 15 | "google.golang.org/protobuf/internal/flags" |
Damien Neil | e89e624 | 2019-05-13 23:55:40 -0700 | [diff] [blame] | 16 | "google.golang.org/protobuf/proto" |
Damien Neil | 01c0e8d | 2019-11-12 12:33:12 -0800 | [diff] [blame^] | 17 | pref "google.golang.org/protobuf/reflect/protoreflect" |
Damien Neil | 3016b73 | 2019-04-07 12:43:10 -0700 | [diff] [blame] | 18 | |
Damien Neil | 01c0e8d | 2019-11-12 12:33:12 -0800 | [diff] [blame^] | 19 | orderpb "google.golang.org/protobuf/internal/testprotos/order" |
Joe Tsai | 9b22b93 | 2019-08-08 19:23:32 -0700 | [diff] [blame] | 20 | testpb "google.golang.org/protobuf/internal/testprotos/test" |
Damien Neil | e89e624 | 2019-05-13 23:55:40 -0700 | [diff] [blame] | 21 | test3pb "google.golang.org/protobuf/internal/testprotos/test3" |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 22 | ) |
| 23 | |
| 24 | func TestEncode(t *testing.T) { |
| 25 | for _, test := range testProtos { |
| 26 | for _, want := range test.decodeTo { |
| 27 | t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) { |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 28 | opts := proto.MarshalOptions{ |
| 29 | AllowPartial: test.partial, |
| 30 | } |
| 31 | wire, err := opts.Marshal(want) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 32 | if err != nil { |
Damien Neil | 61e93c7 | 2019-03-27 09:23:20 -0700 | [diff] [blame] | 33 | t.Fatalf("Marshal error: %v\nMessage:\n%v", err, marshalText(want)) |
| 34 | } |
| 35 | |
| 36 | size := proto.Size(want) |
| 37 | if size != len(wire) { |
| 38 | t.Errorf("Size and marshal disagree: Size(m)=%v; len(Marshal(m))=%v\nMessage:\n%v", size, len(wire), marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 39 | } |
| 40 | |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame] | 41 | got := want.ProtoReflect().New().Interface() |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 42 | uopts := proto.UnmarshalOptions{ |
| 43 | AllowPartial: test.partial, |
| 44 | } |
| 45 | if err := uopts.Unmarshal(wire, got); err != nil { |
Joe Tsai | 8d30bbe | 2019-05-16 15:53:25 -0700 | [diff] [blame] | 46 | t.Errorf("Unmarshal error: %v\nMessage:\n%v", err, marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 47 | return |
| 48 | } |
Damien Neil | e6f060f | 2019-04-23 17:11:02 -0700 | [diff] [blame] | 49 | if !proto.Equal(got, want) { |
Joe Tsai | 8d30bbe | 2019-05-16 15:53:25 -0700 | [diff] [blame] | 50 | t.Errorf("Unmarshal returned unexpected result; got:\n%v\nwant:\n%v", marshalText(got), marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 51 | } |
| 52 | }) |
| 53 | } |
| 54 | } |
| 55 | } |
| 56 | |
| 57 | func TestEncodeDeterministic(t *testing.T) { |
| 58 | for _, test := range testProtos { |
| 59 | for _, want := range test.decodeTo { |
| 60 | t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) { |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 61 | opts := proto.MarshalOptions{ |
| 62 | Deterministic: true, |
| 63 | AllowPartial: test.partial, |
| 64 | } |
| 65 | wire, err := opts.Marshal(want) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 66 | if err != nil { |
Damien Neil | 61e93c7 | 2019-03-27 09:23:20 -0700 | [diff] [blame] | 67 | t.Fatalf("Marshal error: %v\nMessage:\n%v", err, marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 68 | } |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 69 | wire2, err := opts.Marshal(want) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 70 | if err != nil { |
Damien Neil | 61e93c7 | 2019-03-27 09:23:20 -0700 | [diff] [blame] | 71 | t.Fatalf("Marshal error: %v\nMessage:\n%v", err, marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 72 | } |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 73 | if !bytes.Equal(wire, wire2) { |
| 74 | t.Fatalf("deterministic marshal returned varying results:\n%v", cmp.Diff(wire, wire2)) |
| 75 | } |
| 76 | |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame] | 77 | got := want.ProtoReflect().New().Interface() |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 78 | uopts := proto.UnmarshalOptions{ |
| 79 | AllowPartial: test.partial, |
| 80 | } |
| 81 | if err := uopts.Unmarshal(wire, got); err != nil { |
Damien Neil | 61e93c7 | 2019-03-27 09:23:20 -0700 | [diff] [blame] | 82 | t.Errorf("Unmarshal error: %v\nMessage:\n%v", err, marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 83 | return |
| 84 | } |
Damien Neil | e6f060f | 2019-04-23 17:11:02 -0700 | [diff] [blame] | 85 | if !proto.Equal(got, want) { |
Damien Neil | 61e93c7 | 2019-03-27 09:23:20 -0700 | [diff] [blame] | 86 | t.Errorf("Unmarshal returned unexpected result; got:\n%v\nwant:\n%v", marshalText(got), marshalText(want)) |
Damien Neil | 99f24c3 | 2019-03-13 17:06:42 -0700 | [diff] [blame] | 87 | } |
| 88 | }) |
| 89 | } |
| 90 | } |
| 91 | } |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 92 | |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 93 | func TestEncodeInvalidUTF8(t *testing.T) { |
| 94 | for _, test := range invalidUTF8TestProtos { |
| 95 | for _, want := range test.decodeTo { |
| 96 | t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) { |
Damien Neil | 8c86fc5 | 2019-06-19 09:28:29 -0700 | [diff] [blame] | 97 | _, err := proto.Marshal(want) |
| 98 | if err == nil { |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 99 | t.Errorf("Marshal did not return expected error for invalid UTF8: %v\nMessage:\n%v", err, marshalText(want)) |
| 100 | } |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 101 | }) |
| 102 | } |
| 103 | } |
| 104 | } |
| 105 | |
Joe Tsai | c51e2e0 | 2019-07-13 00:44:41 -0700 | [diff] [blame] | 106 | func TestEncodeNoEnforceUTF8(t *testing.T) { |
| 107 | for _, test := range noEnforceUTF8TestProtos { |
| 108 | for _, want := range test.decodeTo { |
| 109 | t.Run(fmt.Sprintf("%s (%T)", test.desc, want), func(t *testing.T) { |
| 110 | _, err := proto.Marshal(want) |
| 111 | switch { |
Joe Tsai | 1799d11 | 2019-08-08 13:31:59 -0700 | [diff] [blame] | 112 | case flags.ProtoLegacy && err != nil: |
Joe Tsai | c51e2e0 | 2019-07-13 00:44:41 -0700 | [diff] [blame] | 113 | t.Errorf("Marshal returned unexpected error: %v\nMessage:\n%v", err, marshalText(want)) |
Joe Tsai | 1799d11 | 2019-08-08 13:31:59 -0700 | [diff] [blame] | 114 | case !flags.ProtoLegacy && err == nil: |
Joe Tsai | c51e2e0 | 2019-07-13 00:44:41 -0700 | [diff] [blame] | 115 | t.Errorf("Marshal did not return expected error for invalid UTF8: %v\nMessage:\n%v", err, marshalText(want)) |
| 116 | } |
| 117 | }) |
| 118 | } |
| 119 | } |
| 120 | } |
| 121 | |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 122 | func TestEncodeRequiredFieldChecks(t *testing.T) { |
| 123 | for _, test := range testProtos { |
| 124 | if !test.partial { |
| 125 | continue |
| 126 | } |
| 127 | for _, m := range test.decodeTo { |
| 128 | t.Run(fmt.Sprintf("%s (%T)", test.desc, m), func(t *testing.T) { |
| 129 | _, err := proto.Marshal(m) |
| 130 | if err == nil { |
| 131 | t.Fatalf("Marshal succeeded (want error)\nMessage:\n%v", marshalText(m)) |
| 132 | } |
| 133 | }) |
| 134 | } |
| 135 | } |
| 136 | } |
Damien Neil | 3016b73 | 2019-04-07 12:43:10 -0700 | [diff] [blame] | 137 | |
Joe Tsai | 9b22b93 | 2019-08-08 19:23:32 -0700 | [diff] [blame] | 138 | func TestEncodeAppend(t *testing.T) { |
Damien Neil | 3016b73 | 2019-04-07 12:43:10 -0700 | [diff] [blame] | 139 | want := []byte("prefix") |
| 140 | got := append([]byte(nil), want...) |
| 141 | got, err := proto.MarshalOptions{}.MarshalAppend(got, &test3pb.TestAllTypes{ |
| 142 | OptionalString: "value", |
| 143 | }) |
| 144 | if err != nil { |
| 145 | t.Fatal(err) |
| 146 | } |
| 147 | if !bytes.HasPrefix(got, want) { |
| 148 | t.Fatalf("MarshalAppend modified prefix: got %v, want prefix %v", got, want) |
| 149 | } |
| 150 | } |
Joe Tsai | 9b22b93 | 2019-08-08 19:23:32 -0700 | [diff] [blame] | 151 | |
| 152 | func TestEncodeOneofNilWrapper(t *testing.T) { |
| 153 | m := &testpb.TestAllTypes{OneofField: (*testpb.TestAllTypes_OneofUint32)(nil)} |
| 154 | b, err := proto.Marshal(m) |
| 155 | if err != nil { |
| 156 | t.Fatal(err) |
| 157 | } |
| 158 | if len(b) > 0 { |
| 159 | t.Errorf("Marshal return non-empty, want empty") |
| 160 | } |
| 161 | } |
Damien Neil | 1e5516a | 2019-09-27 14:31:10 -0700 | [diff] [blame] | 162 | |
| 163 | func TestMarshalAppendAllocations(t *testing.T) { |
| 164 | m := &test3pb.TestAllTypes{OptionalInt32: 1} |
| 165 | size := proto.Size(m) |
| 166 | const count = 1000 |
| 167 | b := make([]byte, size) |
| 168 | // AllocsPerRun returns an integral value. |
| 169 | marshalAllocs := testing.AllocsPerRun(count, func() { |
| 170 | _, err := proto.MarshalOptions{}.MarshalAppend(b[:0], m) |
| 171 | if err != nil { |
| 172 | t.Fatal(err) |
| 173 | } |
| 174 | }) |
| 175 | b = nil |
| 176 | marshalAppendAllocs := testing.AllocsPerRun(count, func() { |
| 177 | var err error |
| 178 | b, err = proto.MarshalOptions{}.MarshalAppend(b, m) |
| 179 | if err != nil { |
| 180 | t.Fatal(err) |
| 181 | } |
| 182 | }) |
| 183 | if marshalAllocs != marshalAppendAllocs { |
| 184 | t.Errorf("%v allocs/op when writing to a preallocated buffer", marshalAllocs) |
| 185 | t.Errorf("%v allocs/op when repeatedly appending to a slice", marshalAppendAllocs) |
| 186 | t.Errorf("expect amortized allocs/op to be identical") |
| 187 | } |
| 188 | } |
Damien Neil | 01c0e8d | 2019-11-12 12:33:12 -0800 | [diff] [blame^] | 189 | |
| 190 | func TestEncodeOrder(t *testing.T) { |
| 191 | // We make no guarantees about the stability of wire marshal output. |
| 192 | // The order in which fields are marshaled may change over time. |
| 193 | // If deterministic marshaling is not enabled, it may change over |
| 194 | // successive calls to proto.Marshal in the same binary. |
| 195 | // |
| 196 | // Unfortunately, many users have come to rely on the specific current |
| 197 | // wire marshal output. Perhaps someday we will choose to deliberately |
| 198 | // change the marshal output; until that day comes, this test verifies |
| 199 | // that we don't unintentionally change it. |
| 200 | m := &orderpb.Message{ |
| 201 | Field_1: proto.String("one"), |
| 202 | Field_2: proto.String("two"), |
| 203 | Field_20: proto.String("twenty"), |
| 204 | Oneof_1: &orderpb.Message_Field_10{"ten"}, |
| 205 | } |
| 206 | proto.SetExtension(m, orderpb.E_Field_30, "thirty") |
| 207 | proto.SetExtension(m, orderpb.E_Field_31, "thirty-one") |
| 208 | proto.SetExtension(m, orderpb.E_Field_32, "thirty-two") |
| 209 | want := []pref.FieldNumber{ |
| 210 | 30, 31, 32, // extensions first, in number order |
| 211 | 1, 2, 20, // non-extension, non-oneof in number order |
| 212 | 10, // oneofs last, undefined order |
| 213 | } |
| 214 | |
| 215 | // Test with deterministic serialization, since fields are not sorted without |
| 216 | // it when -tags=protoreflect. |
| 217 | b, err := proto.MarshalOptions{Deterministic: true}.Marshal(m) |
| 218 | if err != nil { |
| 219 | t.Fatal(err) |
| 220 | } |
| 221 | var got []pref.FieldNumber |
| 222 | for len(b) > 0 { |
| 223 | num, _, n := wire.ConsumeField(b) |
| 224 | if n < 0 { |
| 225 | t.Fatal(wire.ParseError(n)) |
| 226 | } |
| 227 | b = b[n:] |
| 228 | got = append(got, num) |
| 229 | } |
| 230 | if !reflect.DeepEqual(got, want) { |
| 231 | t.Errorf("unexpected field marshal order:\ngot: %v\nwant: %v\nmessage:\n%v", got, want, m) |
| 232 | } |
| 233 | } |