proto: add text tests
These tests were removed during an era when we thought that
the v1 text implementation would just wrap the v2 implementation.
That didn't happen since too much code depended on the exact behavior
of the v1 implementation (exact output, bugs, error strings, etc).
Add the tests back in.
This is a cleaned up version of the tests from v1.3.3.
Change-Id: I0419af2092c4ed5703636366844ea61e910c5908
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/220351
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/proto/text_test.go b/proto/text_test.go
new file mode 100644
index 0000000..343f93a
--- /dev/null
+++ b/proto/text_test.go
@@ -0,0 +1,1366 @@
+// Copyright 2016 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 (
+ "bytes"
+ "errors"
+ "math"
+ "strings"
+ "sync"
+ "testing"
+
+ "github.com/golang/protobuf/proto"
+ "github.com/google/go-cmp/cmp"
+
+ pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto"
+ pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto"
+ anypb "github.com/golang/protobuf/ptypes/any"
+)
+
+var (
+ expandedMarshaler = proto.TextMarshaler{ExpandAny: true}
+ expandedCompactMarshaler = proto.TextMarshaler{Compact: true, ExpandAny: true}
+)
+
+// anyEqual reports whether two messages which may be google.protobuf.Any or may
+// contain google.protobuf.Any fields are equal. We can't use proto.Equal for
+// comparison, because semantically equivalent messages may be marshaled to
+// binary in different tag order. Instead, trust that TextMarshaler with
+// ExpandAny option works and compare the text marshaling results.
+func anyEqual(got, want proto.Message) bool {
+ // if messages are proto.Equal, no need to marshal.
+ if proto.Equal(got, want) {
+ return true
+ }
+ g := expandedMarshaler.Text(got)
+ w := expandedMarshaler.Text(want)
+ return g == w
+}
+
+type golden struct {
+ m proto.Message
+ t, c string
+}
+
+var goldenMessages = makeGolden()
+
+func makeGolden() []golden {
+ nested := &pb3.Nested{Bunny: "Monty"}
+ nb, err := proto.Marshal(nested)
+ if err != nil {
+ panic(err)
+ }
+ m1 := &pb3.Message{
+ Name: "David",
+ ResultCount: 47,
+ Anything: &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb},
+ }
+ m2 := &pb3.Message{
+ Name: "David",
+ ResultCount: 47,
+ Anything: &anypb.Any{TypeUrl: "http://[::1]/type.googleapis.com/" + proto.MessageName(nested), Value: nb},
+ }
+ m3 := &pb3.Message{
+ Name: "David",
+ ResultCount: 47,
+ Anything: &anypb.Any{TypeUrl: `type.googleapis.com/"/` + proto.MessageName(nested), Value: nb},
+ }
+ m4 := &pb3.Message{
+ Name: "David",
+ ResultCount: 47,
+ Anything: &anypb.Any{TypeUrl: "type.googleapis.com/a/path/" + proto.MessageName(nested), Value: nb},
+ }
+ m5 := &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb}
+
+ any1 := &pb2.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
+ proto.SetExtension(any1, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("foo")})
+ proto.SetExtension(any1, pb2.E_Ext_Text, proto.String("bar"))
+ any1b, err := proto.Marshal(any1)
+ if err != nil {
+ panic(err)
+ }
+ any2 := &pb2.MyMessage{Count: proto.Int32(42), Bikeshed: pb2.MyMessage_GREEN.Enum(), RepBytes: [][]byte{[]byte("roboto")}}
+ proto.SetExtension(any2, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("baz")})
+ any2b, err := proto.Marshal(any2)
+ if err != nil {
+ panic(err)
+ }
+ m6 := &pb3.Message{
+ Name: "David",
+ ResultCount: 47,
+ Anything: &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
+ ManyThings: []*anypb.Any{
+ &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any2), Value: any2b},
+ &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b},
+ },
+ }
+
+ const (
+ m1Golden = `
+name: "David"
+result_count: 47
+anything: <
+ [type.googleapis.com/proto3_test.Nested]: <
+ bunny: "Monty"
+ >
+>
+`
+ m2Golden = `
+name: "David"
+result_count: 47
+anything: <
+ ["http://[::1]/type.googleapis.com/proto3_test.Nested"]: <
+ bunny: "Monty"
+ >
+>
+`
+ m3Golden = `
+name: "David"
+result_count: 47
+anything: <
+ ["type.googleapis.com/\"/proto3_test.Nested"]: <
+ bunny: "Monty"
+ >
+>
+`
+ m4Golden = `
+name: "David"
+result_count: 47
+anything: <
+ [type.googleapis.com/a/path/proto3_test.Nested]: <
+ bunny: "Monty"
+ >
+>
+`
+ m5Golden = `
+[type.googleapis.com/proto3_test.Nested]: <
+ bunny: "Monty"
+>
+`
+ m6Golden = `
+name: "David"
+result_count: 47
+anything: <
+ [type.googleapis.com/proto2_test.MyMessage]: <
+ count: 47
+ name: "David"
+ [proto2_test.Ext.more]: <
+ data: "foo"
+ >
+ [proto2_test.Ext.text]: "bar"
+ >
+>
+many_things: <
+ [type.googleapis.com/proto2_test.MyMessage]: <
+ count: 42
+ bikeshed: GREEN
+ rep_bytes: "roboto"
+ [proto2_test.Ext.more]: <
+ data: "baz"
+ >
+ >
+>
+many_things: <
+ [type.googleapis.com/proto2_test.MyMessage]: <
+ count: 47
+ name: "David"
+ [proto2_test.Ext.more]: <
+ data: "foo"
+ >
+ [proto2_test.Ext.text]: "bar"
+ >
+>
+`
+ )
+ return []golden{
+ {m1, strings.TrimSpace(m1Golden) + "\n", strings.TrimSpace(compact(m1Golden)) + " "},
+ {m2, strings.TrimSpace(m2Golden) + "\n", strings.TrimSpace(compact(m2Golden)) + " "},
+ {m3, strings.TrimSpace(m3Golden) + "\n", strings.TrimSpace(compact(m3Golden)) + " "},
+ {m4, strings.TrimSpace(m4Golden) + "\n", strings.TrimSpace(compact(m4Golden)) + " "},
+ {m5, strings.TrimSpace(m5Golden) + "\n", strings.TrimSpace(compact(m5Golden)) + " "},
+ {m6, strings.TrimSpace(m6Golden) + "\n", strings.TrimSpace(compact(m6Golden)) + " "},
+ }
+}
+
+func TestMarshalGolden(t *testing.T) {
+ for _, tt := range goldenMessages {
+ t.Run("", func(t *testing.T) {
+ if got, want := expandedMarshaler.Text(tt.m), tt.t; got != want {
+ t.Errorf("message %v: got:\n%s\nwant:\n%s", tt.m, got, want)
+ }
+ if got, want := expandedCompactMarshaler.Text(tt.m), tt.c; got != want {
+ t.Errorf("message %v: got:\n`%s`\nwant:\n`%s`", tt.m, got, want)
+ }
+ })
+ }
+}
+
+func TestUnmarshalGolden(t *testing.T) {
+ for _, tt := range goldenMessages {
+ t.Run("", func(t *testing.T) {
+ want := tt.m
+ got := proto.Clone(tt.m)
+ got.Reset()
+ if err := proto.UnmarshalText(tt.t, got); err != nil {
+ t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.t, err)
+ }
+ if !anyEqual(got, want) {
+ t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.t, got, want)
+ }
+ got.Reset()
+ if err := proto.UnmarshalText(tt.c, got); err != nil {
+ t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.c, err)
+ }
+ if !anyEqual(got, want) {
+ t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.c, got, want)
+ }
+ })
+ }
+}
+
+func TestMarshalUnknownAny(t *testing.T) {
+ m := &pb3.Message{
+ Anything: &anypb.Any{
+ TypeUrl: "foo",
+ Value: []byte("bar"),
+ },
+ }
+ want := `anything: <
+ type_url: "foo"
+ value: "bar"
+>
+`
+ got := expandedMarshaler.Text(m)
+ if got != want {
+ t.Errorf("got:\n%s\nwant:\n%s", got, want)
+ }
+}
+
+func TestAmbiguousAny(t *testing.T) {
+ pb := &anypb.Any{}
+ err := proto.UnmarshalText(`
+ type_url: "ttt/proto3_test.Nested"
+ value: "\n\x05Monty"
+ `, pb)
+ if err != nil {
+ t.Errorf("unexpected proto.UnmarshalText error: %v", err)
+ }
+}
+
+func TestUnmarshalOverwriteAny(t *testing.T) {
+ pb := &anypb.Any{}
+ err := proto.UnmarshalText(`
+ [type.googleapis.com/a/path/proto3_test.Nested]: <
+ bunny: "Monty"
+ >
+ [type.googleapis.com/a/path/proto3_test.Nested]: <
+ bunny: "Rabbit of Caerbannog"
+ >
+ `, pb)
+ want := `line 7: Any message unpacked multiple times, or "type_url" already set`
+ if err.Error() != want {
+ t.Errorf("incorrect error:\ngot: %v\nwant: %v", err.Error(), want)
+ }
+}
+
+func TestUnmarshalAnyMixAndMatch(t *testing.T) {
+ pb := &anypb.Any{}
+ err := proto.UnmarshalText(`
+ value: "\n\x05Monty"
+ [type.googleapis.com/a/path/proto3_test.Nested]: <
+ bunny: "Rabbit of Caerbannog"
+ >
+ `, pb)
+ want := `line 5: Any message unpacked multiple times, or "value" already set`
+ if err.Error() != want {
+ t.Errorf("incorrect error:\ngot: %v\nwant: %v", err.Error(), want)
+ }
+}
+
+// textMessage implements the methods that allow it to marshal and unmarshal
+// itself as text.
+type textMessage struct {
+}
+
+func (*textMessage) MarshalText() ([]byte, error) {
+ return []byte("custom"), nil
+}
+
+func (*textMessage) UnmarshalText(bytes []byte) error {
+ if string(bytes) != "custom" {
+ return errors.New("expected 'custom'")
+ }
+ return nil
+}
+
+func (*textMessage) Reset() {}
+func (*textMessage) String() string { return "" }
+func (*textMessage) ProtoMessage() {}
+
+func newTestMessage() *pb2.MyMessage {
+ msg := &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("Dave"),
+ Quote: proto.String(`"I didn't want to go."`),
+ Pet: []string{"bunny", "kitty", "horsey"},
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("footrest.syd"),
+ Port: proto.Int32(7001),
+ Connected: proto.Bool(true),
+ },
+ Others: []*pb2.OtherMessage{
+ {
+ Key: proto.Int64(0xdeadbeef),
+ Value: []byte{1, 65, 7, 12},
+ },
+ {
+ Weight: proto.Float32(6.022),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("lesha.mtv"),
+ Port: proto.Int32(8002),
+ },
+ },
+ },
+ Bikeshed: pb2.MyMessage_BLUE.Enum(),
+ Somegroup: &pb2.MyMessage_SomeGroup{
+ GroupField: proto.Int32(8),
+ },
+ // One normally wouldn't do this.
+ // This is an undeclared tag 13, as a varint (wire type 0) with value 4.
+ XXX_unrecognized: []byte{13<<3 | 0, 4},
+ }
+ ext := &pb2.Ext{
+ Data: proto.String("Big gobs for big rats"),
+ }
+ if err := proto.SetExtension(msg, pb2.E_Ext_More, ext); err != nil {
+ panic(err)
+ }
+ greetings := []string{"adg", "easy", "cow"}
+ if err := proto.SetExtension(msg, pb2.E_Greeting, greetings); err != nil {
+ panic(err)
+ }
+
+ // Add an unknown extension. We marshal a pb2.Ext, and fake the ID.
+ b, err := proto.Marshal(&pb2.Ext{Data: proto.String("3G skiing")})
+ if err != nil {
+ panic(err)
+ }
+ b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...)
+ proto.SetRawExtension(msg, 201, b)
+
+ // Extensions can be plain fields, too, so let's test that.
+ b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19)
+ proto.SetRawExtension(msg, 202, b)
+
+ return msg
+}
+
+const text = `count: 42
+name: "Dave"
+quote: "\"I didn't want to go.\""
+pet: "bunny"
+pet: "kitty"
+pet: "horsey"
+inner: <
+ host: "footrest.syd"
+ port: 7001
+ connected: true
+>
+others: <
+ key: 3735928559
+ value: "\001A\007\014"
+>
+others: <
+ weight: 6.022
+ inner: <
+ host: "lesha.mtv"
+ port: 8002
+ >
+>
+bikeshed: BLUE
+SomeGroup {
+ group_field: 8
+}
+/* 18 unknown bytes */
+13: 4
+201: "\t3G skiing"
+202: 19
+[proto2_test.Ext.more]: <
+ data: "Big gobs for big rats"
+>
+[proto2_test.greeting]: "adg"
+[proto2_test.greeting]: "easy"
+[proto2_test.greeting]: "cow"
+`
+
+func TestMarshalText(t *testing.T) {
+ buf := new(bytes.Buffer)
+ if err := proto.MarshalText(buf, newTestMessage()); err != nil {
+ t.Fatalf("proto.MarshalText: %v", err)
+ }
+ got := buf.String()
+ if diff := cmp.Diff(text, got); got != text {
+ t.Errorf("diff (-want +got):\n%v\n\ngot:\n%v\n\nwant:\n%v", diff, got, text)
+ }
+}
+
+func TestMarshalTextCustomMessage(t *testing.T) {
+ buf := new(bytes.Buffer)
+ if err := proto.MarshalText(buf, &textMessage{}); err != nil {
+ t.Fatalf("proto.MarshalText: %v", err)
+ }
+ got := buf.String()
+ if got != "custom" {
+ t.Errorf("got:\n%v\n\nwant:\n%v", got, "custom")
+ }
+}
+func TestMarshalTextNil(t *testing.T) {
+ want := "<nil>"
+ tests := []proto.Message{nil, (*pb2.MyMessage)(nil)}
+ for i, test := range tests {
+ buf := new(bytes.Buffer)
+ if err := proto.MarshalText(buf, test); err != nil {
+ t.Fatal(err)
+ }
+ if got := buf.String(); got != want {
+ t.Errorf("%d: got %q want %q", i, got, want)
+ }
+ }
+}
+
+func TestMarshalTextUnknownEnum(t *testing.T) {
+ // The Color enum only specifies values 0-2.
+ m := &pb2.MyMessage{Bikeshed: pb2.MyMessage_Color(3).Enum()}
+ got := m.String()
+ const want = `bikeshed:3 `
+ if got != want {
+ t.Errorf("\n got %q\nwant %q", got, want)
+ }
+}
+
+func TestTextOneof(t *testing.T) {
+ tests := []struct {
+ m proto.Message
+ want string
+ }{
+ // zero message
+ {&pb2.Communique{}, ``},
+ // scalar field
+ {&pb2.Communique{Union: &pb2.Communique_Number{4}}, `number:4`},
+ // message field
+ {&pb2.Communique{Union: &pb2.Communique_Msg{
+ &pb2.Strings{StringField: proto.String("why hello!")},
+ }}, `msg:<string_field:"why hello!" >`},
+ // bad oneof (should not panic)
+ {&pb2.Communique{Union: &pb2.Communique_Msg{nil}}, `msg:<>`},
+ }
+ for _, test := range tests {
+ got := strings.TrimSpace(test.m.String())
+ if got != test.want {
+ t.Errorf("got:\n%s\n\nwant:\n%s", got, test.want)
+ }
+ }
+}
+
+func compact(src string) string {
+ // s/[ \n]+/ /g; s/ $//;
+ dst := make([]byte, len(src))
+ space, comment := false, false
+ j := 0
+ for i := 0; i < len(src); i++ {
+ if strings.HasPrefix(src[i:], "/*") {
+ comment = true
+ i++
+ continue
+ }
+ if comment && strings.HasPrefix(src[i:], "*/") {
+ comment = false
+ i++
+ continue
+ }
+ if comment {
+ continue
+ }
+ c := src[i]
+ if c == ' ' || c == '\n' {
+ space = true
+ continue
+ }
+ if j > 0 && (dst[j-1] == ':' || dst[j-1] == '<' || dst[j-1] == '{') {
+ space = false
+ }
+ if c == '{' {
+ space = false
+ }
+ if space {
+ dst[j] = ' '
+ j++
+ space = false
+ }
+ dst[j] = c
+ j++
+ }
+ if space {
+ dst[j] = ' '
+ j++
+ }
+ return string(dst[0:j])
+}
+
+func TestCompactText(t *testing.T) {
+ got := proto.CompactTextString(newTestMessage())
+ if got != compact(text) {
+ t.Errorf("got:\n%v\n\nwant:\n%v", got, compact(text))
+ }
+}
+
+func TestStringEscaping(t *testing.T) {
+ testCases := []struct {
+ in *pb2.Strings
+ out string
+ }{
+ {
+ // Test data from C++ test (TextFormatTest.StringEscape).
+ // Single divergence: we don't escape apostrophes.
+ &pb2.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and multiple spaces")},
+ "string_field: \"\\\"A string with ' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and multiple spaces\"\n",
+ },
+ {
+ // Test data from the same C++ test.
+ &pb2.Strings{StringField: proto.String("\350\260\267\346\255\214")},
+ "string_field: \"\\350\\260\\267\\346\\255\\214\"\n",
+ },
+ {
+ // Some UTF-8.
+ &pb2.Strings{StringField: proto.String("\x00\x01\xff\x81")},
+ `string_field: "\000\001\377\201"` + "\n",
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ var buf bytes.Buffer
+ if err := proto.MarshalText(&buf, tc.in); err != nil {
+ t.Fatalf("proto.MarsalText error: %v", err)
+ }
+ got := buf.String()
+ if got != tc.out {
+ t.Fatalf("want:\n%s\n\nwant:\n%s", got, tc.out)
+ }
+
+ // Check round-trip.
+ pb := new(pb2.Strings)
+ if err := proto.UnmarshalText(got, pb); err != nil {
+ t.Fatalf("proto.UnmarshalText error: %v", err)
+ }
+ if !proto.Equal(pb, tc.in) {
+ t.Fatalf("proto.Equal mismatch:\ngot:\n%v\n\nwant:\n%v", pb, tc.in)
+ }
+ })
+ }
+}
+
+// A limitedWriter accepts some output before it fails.
+// This is a proxy for something like a nearly-full or imminently-failing disk,
+// or a network connection that is about to die.
+type limitedWriter struct {
+ b bytes.Buffer
+ limit int
+}
+
+var outOfSpace = errors.New("proto: insufficient space")
+
+func (w *limitedWriter) Write(p []byte) (n int, err error) {
+ var avail = w.limit - w.b.Len()
+ if avail <= 0 {
+ return 0, outOfSpace
+ }
+ if len(p) <= avail {
+ return w.b.Write(p)
+ }
+ n, _ = w.b.Write(p[:avail])
+ return n, outOfSpace
+}
+
+func TestMarshalTextFailing(t *testing.T) {
+ // Try lots of different sizes to exercise more error code-paths.
+ for lim := 0; lim < len(text); lim++ {
+ buf := new(limitedWriter)
+ buf.limit = lim
+ err := proto.MarshalText(buf, newTestMessage())
+ // We expect a certain error, but also some partial results in the buffer.
+ if err != outOfSpace {
+ t.Errorf("error mismatch: got %v, want %v", err, outOfSpace)
+ }
+ got := buf.b.String()
+ want := text[:buf.limit]
+ if got != want {
+ t.Errorf("text mismatch:\n\ngot:\n%v\n\nwant:\n%v", got, want)
+ }
+ }
+}
+
+func TestFloats(t *testing.T) {
+ tests := []struct {
+ f float64
+ want string
+ }{
+ {0, "0"},
+ {4.7, "4.7"},
+ {math.Inf(1), "inf"},
+ {math.Inf(-1), "-inf"},
+ {math.NaN(), "nan"},
+ }
+ for _, test := range tests {
+ msg := &pb2.FloatingPoint{F: &test.f}
+ got := strings.TrimSpace(msg.String())
+ want := `f:` + test.want
+ if got != want {
+ t.Errorf("f=%f: got %q, want %q", test.f, got, want)
+ }
+ }
+}
+
+func TestRepeatedNilText(t *testing.T) {
+ m := &pb2.MessageList{
+ Message: []*pb2.MessageList_Message{
+ nil,
+ &pb2.MessageList_Message{
+ Name: proto.String("Horse"),
+ },
+ nil,
+ },
+ }
+ want := `Message {
+}
+Message {
+ name: "Horse"
+}
+Message {
+}
+`
+ if got := proto.MarshalTextString(m); got != want {
+ t.Errorf("got:\n%s\n\nwant:\n%s", got, want)
+ }
+}
+
+func TestProto3Text(t *testing.T) {
+ tests := []struct {
+ m proto.Message
+ want string
+ }{
+ // zero message
+ {&pb3.Message{}, ``},
+ // zero message except for an empty byte slice
+ {&pb3.Message{Data: []byte{}}, ``},
+ // trivial case
+ {&pb3.Message{Name: "Rob", HeightInCm: 175}, `name:"Rob" height_in_cm:175`},
+ // empty map
+ {&pb2.MessageWithMap{}, ``},
+ // non-empty map; map format is the same as a repeated struct,
+ // and they are sorted by key (numerically for numeric keys).
+ {
+ &pb2.MessageWithMap{NameMapping: map[int32]string{
+ -1: "Negatory",
+ 7: "Lucky",
+ 1234: "Feist",
+ 6345789: "Otis",
+ }},
+ `name_mapping:<key:-1 value:"Negatory" > ` +
+ `name_mapping:<key:7 value:"Lucky" > ` +
+ `name_mapping:<key:1234 value:"Feist" > ` +
+ `name_mapping:<key:6345789 value:"Otis" >`,
+ },
+ // map with nil value; not well-defined, but we shouldn't crash
+ {
+ &pb2.MessageWithMap{MsgMapping: map[int64]*pb2.FloatingPoint{7: nil}},
+ `msg_mapping:<key:7 value:<> >`,
+ },
+ }
+ for _, test := range tests {
+ got := strings.TrimSpace(test.m.String())
+ if got != test.want {
+ t.Errorf("got:\n%s\n\nwant:\n%s", got, test.want)
+ }
+ }
+}
+
+func TestRacyMarshal(t *testing.T) {
+ // This test should be run with the race detector.
+
+ any := &pb2.MyMessage{Count: proto.Int32(47), Name: proto.String("David")}
+ proto.SetExtension(any, pb2.E_Ext_Text, proto.String("bar"))
+ b, err := proto.Marshal(any)
+ if err != nil {
+ panic(err)
+ }
+ m := &pb3.Message{
+ Name: "David",
+ ResultCount: 47,
+ Anything: &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any), Value: b},
+ }
+
+ wantText := proto.MarshalTextString(m)
+ wantBytes, err := proto.Marshal(m)
+ if err != nil {
+ t.Fatalf("proto.Marshal error: %v", err)
+ }
+
+ var wg sync.WaitGroup
+ defer wg.Wait()
+ wg.Add(20)
+ for i := 0; i < 10; i++ {
+ go func() {
+ defer wg.Done()
+ got := proto.MarshalTextString(m)
+ if got != wantText {
+ t.Errorf("proto.MarshalTextString = %q, want %q", got, wantText)
+ }
+ }()
+ go func() {
+ defer wg.Done()
+ got, err := proto.Marshal(m)
+ if !bytes.Equal(got, wantBytes) || err != nil {
+ t.Errorf("proto.Marshal = (%x, %v), want (%x, nil)", got, err, wantBytes)
+ }
+ }()
+ }
+}
+
+type UnmarshalTextTest struct {
+ in string
+ err string // if "", no error expected
+ out *pb2.MyMessage
+}
+
+func buildExtStructTest(text string) UnmarshalTextTest {
+ msg := &pb2.MyMessage{
+ Count: proto.Int32(42),
+ }
+ proto.SetExtension(msg, pb2.E_Ext_More, &pb2.Ext{
+ Data: proto.String("Hello, world!"),
+ })
+ return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtDataTest(text string) UnmarshalTextTest {
+ msg := &pb2.MyMessage{
+ Count: proto.Int32(42),
+ }
+ proto.SetExtension(msg, pb2.E_Ext_Text, proto.String("Hello, world!"))
+ proto.SetExtension(msg, pb2.E_Ext_Number, proto.Int32(1729))
+ return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtRepStringTest(text string) UnmarshalTextTest {
+ msg := &pb2.MyMessage{
+ Count: proto.Int32(42),
+ }
+ if err := proto.SetExtension(msg, pb2.E_Greeting, []string{"bula", "hola"}); err != nil {
+ panic(err)
+ }
+ return UnmarshalTextTest{in: text, out: msg}
+}
+
+var unmarshalTextTests = []UnmarshalTextTest{
+ // Basic
+ {
+ in: " count:42\n name:\"Dave\" ",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("Dave"),
+ },
+ },
+
+ // Empty quoted string
+ {
+ in: `count:42 name:""`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String(""),
+ },
+ },
+
+ // Quoted string concatenation with double quotes
+ {
+ in: `count:42 name: "My name is "` + "\n" + `"elsewhere"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("My name is elsewhere"),
+ },
+ },
+
+ // Quoted string concatenation with single quotes
+ {
+ in: "count:42 name: 'My name is '\n'elsewhere'",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("My name is elsewhere"),
+ },
+ },
+
+ // Quoted string concatenations with mixed quotes
+ {
+ in: "count:42 name: 'My name is '\n\"elsewhere\"",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("My name is elsewhere"),
+ },
+ },
+ {
+ in: "count:42 name: \"My name is \"\n'elsewhere'",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("My name is elsewhere"),
+ },
+ },
+
+ // Quoted string with escaped apostrophe
+ {
+ in: `count:42 name: "HOLIDAY - New Year\'s Day"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("HOLIDAY - New Year's Day"),
+ },
+ },
+
+ // Quoted string with single quote
+ {
+ in: `count:42 name: 'Roger "The Ramster" Ramjet'`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String(`Roger "The Ramster" Ramjet`),
+ },
+ },
+
+ // Quoted string with all the accepted special characters from the C++ test
+ {
+ in: `count:42 name: ` + "\"\\\"A string with \\' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and multiple spaces\"",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and multiple spaces"),
+ },
+ },
+
+ // Quoted string with quoted backslash
+ {
+ in: `count:42 name: "\\'xyz"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String(`\'xyz`),
+ },
+ },
+
+ // Quoted string with UTF-8 bytes.
+ {
+ in: "count:42 name: '\303\277\302\201\x00\xAB\xCD\xEF'",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("\303\277\302\201\x00\xAB\xCD\xEF"),
+ },
+ },
+
+ // Quoted string with unicode escapes.
+ {
+ in: `count: 42 name: "\u0047\U00000047\uffff\U0010ffff"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("GG\uffff\U0010ffff"),
+ },
+ },
+
+ // Bad quoted string
+ {
+ in: `inner: < host: "\0" >` + "\n",
+ err: `line 1.15: invalid quoted string "\0": \0 requires 2 following digits`,
+ },
+
+ // Bad \u escape
+ {
+ in: `count: 42 name: "\u000"`,
+ err: `line 1.16: invalid quoted string "\u000": \u requires 4 following digits`,
+ },
+
+ // Bad \U escape
+ {
+ in: `count: 42 name: "\U0000000"`,
+ err: `line 1.16: invalid quoted string "\U0000000": \U requires 8 following digits`,
+ },
+
+ // Bad \U escape
+ {
+ in: `count: 42 name: "\xxx"`,
+ err: `line 1.16: invalid quoted string "\xxx": \xxx contains non-hexadecimal digits`,
+ },
+
+ // Number too large for int64
+ {
+ in: "count: 1 others { key: 123456789012345678901 }",
+ err: "line 1.23: invalid int64: 123456789012345678901",
+ },
+
+ // Number too large for int32
+ {
+ in: "count: 1234567890123",
+ err: "line 1.7: invalid int32: 1234567890123",
+ },
+
+ // Number in hexadecimal
+ {
+ in: "count: 0x2beef",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(0x2beef),
+ },
+ },
+
+ // Number in octal
+ {
+ in: "count: 024601",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(024601),
+ },
+ },
+
+ // Floating point number with "f" suffix
+ {
+ in: "count: 4 others:< weight: 17.0f >",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(4),
+ Others: []*pb2.OtherMessage{
+ {
+ Weight: proto.Float32(17),
+ },
+ },
+ },
+ },
+
+ // Floating point positive infinity
+ {
+ in: "count: 4 bigfloat: inf",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(4),
+ Bigfloat: proto.Float64(math.Inf(1)),
+ },
+ },
+
+ // Floating point negative infinity
+ {
+ in: "count: 4 bigfloat: -inf",
+ out: &pb2.MyMessage{
+ Count: proto.Int32(4),
+ Bigfloat: proto.Float64(math.Inf(-1)),
+ },
+ },
+
+ // Number too large for float32
+ {
+ in: "others:< weight: 12345678901234567890123456789012345678901234567890 >",
+ err: "line 1.17: invalid float: 12345678901234567890123456789012345678901234567890",
+ },
+
+ // Number posing as a quoted string
+ {
+ in: `inner: < host: 12 >` + "\n",
+ err: `line 1.15: invalid string: 12`,
+ },
+
+ // Quoted string posing as int32
+ {
+ in: `count: "12"`,
+ err: `line 1.7: invalid int32: "12"`,
+ },
+
+ // Quoted string posing a float32
+ {
+ in: `others:< weight: "17.4" >`,
+ err: `line 1.17: invalid float: "17.4"`,
+ },
+
+ // unclosed bracket doesn't cause infinite loop
+ {
+ in: `[`,
+ err: `line 1.0: unclosed type_url or extension name`,
+ },
+
+ // Enum
+ {
+ in: `count:42 bikeshed: BLUE`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Bikeshed: pb2.MyMessage_BLUE.Enum(),
+ },
+ },
+
+ // Repeated field
+ {
+ in: `count:42 pet: "horsey" pet:"bunny"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Pet: []string{"horsey", "bunny"},
+ },
+ },
+
+ // Repeated field with list notation
+ {
+ in: `count:42 pet: ["horsey", "bunny"]`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Pet: []string{"horsey", "bunny"},
+ },
+ },
+
+ // Repeated message with/without colon and <>/{}
+ {
+ in: `count:42 others:{} others{} others:<> others:{}`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Others: []*pb2.OtherMessage{
+ {},
+ {},
+ {},
+ {},
+ },
+ },
+ },
+
+ // Missing colon for inner message
+ {
+ in: `count:42 inner < host: "cauchy.syd" >`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("cauchy.syd"),
+ },
+ },
+ },
+
+ // Missing colon for string field
+ {
+ in: `name "Dave"`,
+ err: `line 1.5: expected ':', found "\"Dave\""`,
+ },
+
+ // Missing colon for int32 field
+ {
+ in: `count 42`,
+ err: `line 1.6: expected ':', found "42"`,
+ },
+
+ // Missing required field
+ {
+ in: `name: "Pawel"`,
+ err: `required field proto2_test.MyMessage.count not set`,
+ out: &pb2.MyMessage{
+ Name: proto.String("Pawel"),
+ },
+ },
+
+ // Missing required field in a required submessage
+ {
+ in: `count: 42 we_must_go_deeper < leo_finally_won_an_oscar <> >`,
+ err: `required field proto2_test.InnerMessage.host not set`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ WeMustGoDeeper: &pb2.RequiredInnerMessage{LeoFinallyWonAnOscar: &pb2.InnerMessage{}},
+ },
+ },
+
+ // Repeated non-repeated field
+ {
+ in: `name: "Rob" name: "Russ"`,
+ err: `line 1.12: non-repeated field "name" was repeated`,
+ },
+
+ // Group
+ {
+ in: `count: 17 SomeGroup { group_field: 12 }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(17),
+ Somegroup: &pb2.MyMessage_SomeGroup{
+ GroupField: proto.Int32(12),
+ },
+ },
+ },
+
+ // Semicolon between fields
+ {
+ in: `count:3;name:"Calvin"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(3),
+ Name: proto.String("Calvin"),
+ },
+ },
+ // Comma between fields
+ {
+ in: `count:4,name:"Ezekiel"`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(4),
+ Name: proto.String("Ezekiel"),
+ },
+ },
+
+ // Boolean false
+ {
+ in: `count:42 inner { host: "example.com" connected: false }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(false),
+ },
+ },
+ },
+ // Boolean true
+ {
+ in: `count:42 inner { host: "example.com" connected: true }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(true),
+ },
+ },
+ },
+ // Boolean 0
+ {
+ in: `count:42 inner { host: "example.com" connected: 0 }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(false),
+ },
+ },
+ },
+ // Boolean 1
+ {
+ in: `count:42 inner { host: "example.com" connected: 1 }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(true),
+ },
+ },
+ },
+ // Boolean f
+ {
+ in: `count:42 inner { host: "example.com" connected: f }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(false),
+ },
+ },
+ },
+ // Boolean t
+ {
+ in: `count:42 inner { host: "example.com" connected: t }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(true),
+ },
+ },
+ },
+ // Boolean False
+ {
+ in: `count:42 inner { host: "example.com" connected: False }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(false),
+ },
+ },
+ },
+ // Boolean True
+ {
+ in: `count:42 inner { host: "example.com" connected: True }`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("example.com"),
+ Connected: proto.Bool(true),
+ },
+ },
+ },
+
+ // Extension
+ buildExtStructTest(`count: 42 [proto2_test.Ext.more]:<data:"Hello, world!" >`),
+ buildExtStructTest(`count: 42 [proto2_test.Ext.more] {data:"Hello, world!"}`),
+ buildExtDataTest(`count: 42 [proto2_test.Ext.text]:"Hello, world!" [proto2_test.Ext.number]:1729`),
+ buildExtRepStringTest(`count: 42 [proto2_test.greeting]:"bula" [proto2_test.greeting]:"hola"`),
+
+ // Big all-in-one
+ {
+ in: "count:42 # Meaning\n" +
+ `name:"Dave" ` +
+ `quote:"\"I didn't want to go.\"" ` +
+ `pet:"bunny" ` +
+ `pet:"kitty" ` +
+ `pet:"horsey" ` +
+ `inner:<` +
+ ` host:"footrest.syd" ` +
+ ` port:7001 ` +
+ ` connected:true ` +
+ `> ` +
+ `others:<` +
+ ` key:3735928559 ` +
+ ` value:"\x01A\a\f" ` +
+ `> ` +
+ `others:<` +
+ " weight:58.9 # Atomic weight of Co\n" +
+ ` inner:<` +
+ ` host:"lesha.mtv" ` +
+ ` port:8002 ` +
+ ` >` +
+ `>`,
+ out: &pb2.MyMessage{
+ Count: proto.Int32(42),
+ Name: proto.String("Dave"),
+ Quote: proto.String(`"I didn't want to go."`),
+ Pet: []string{"bunny", "kitty", "horsey"},
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("footrest.syd"),
+ Port: proto.Int32(7001),
+ Connected: proto.Bool(true),
+ },
+ Others: []*pb2.OtherMessage{
+ {
+ Key: proto.Int64(3735928559),
+ Value: []byte{0x1, 'A', '\a', '\f'},
+ },
+ {
+ Weight: proto.Float32(58.9),
+ Inner: &pb2.InnerMessage{
+ Host: proto.String("lesha.mtv"),
+ Port: proto.Int32(8002),
+ },
+ },
+ },
+ },
+ },
+}
+
+func TestUnmarshalText(t *testing.T) {
+ for _, test := range unmarshalTextTests {
+ t.Run("", func(t *testing.T) {
+ pb := new(pb2.MyMessage)
+ err := proto.UnmarshalText(test.in, pb)
+ if test.err == "" {
+ // We don't expect failure.
+ if err != nil {
+ t.Errorf("proto.UnmarshalText error: %v", err)
+ } else if !proto.Equal(pb, test.out) {
+ t.Errorf("proto.Equal mismatch:\ngot: %v\nwant: %v", pb, test.out)
+ }
+ } else {
+ // We do expect failure.
+ if err == nil {
+ t.Errorf("proto.UnmarshalText: got nil error, want %v", test.err)
+ } else if !strings.Contains(err.Error(), test.err) {
+ t.Errorf("proto.UnmarshalText error mismatch:\ngot: %v\nwant: %v", err.Error(), test.err)
+ } else if _, ok := err.(*proto.RequiredNotSetError); ok && test.out != nil && !proto.Equal(pb, test.out) {
+ t.Errorf("proto.Equal mismatch:\ngot %v\nwant: %v", pb, test.out)
+ }
+ }
+ })
+ }
+}
+
+func TestUnmarshalTextCustomMessage(t *testing.T) {
+ msg := &textMessage{}
+ if err := proto.UnmarshalText("custom", msg); err != nil {
+ t.Errorf("proto.UnmarshalText error: %v", err)
+ }
+ if err := proto.UnmarshalText("not custom", msg); err == nil {
+ t.Errorf("proto.UnmarshalText: got nil error, want non-nil")
+ }
+}
+
+// Regression test; this caused a panic.
+func TestRepeatedEnum(t *testing.T) {
+ pb := new(pb2.RepeatedEnum)
+ if err := proto.UnmarshalText("color: RED", pb); err != nil {
+ t.Fatal(err)
+ }
+ exp := &pb2.RepeatedEnum{
+ Color: []pb2.RepeatedEnum_Color{pb2.RepeatedEnum_RED},
+ }
+ if !proto.Equal(pb, exp) {
+ t.Errorf("proto.Equal mismatch:\ngot: %v\nwant %v", pb, exp)
+ }
+}
+
+func TestProto3TextParsing(t *testing.T) {
+ m := new(pb3.Message)
+ const in = `name: "Wallace" true_scotsman: true`
+ want := &pb3.Message{
+ Name: "Wallace",
+ TrueScotsman: true,
+ }
+ if err := proto.UnmarshalText(in, m); err != nil {
+ t.Fatal(err)
+ }
+ if !proto.Equal(m, want) {
+ t.Errorf("proto.Equal mismatch:\ngot: %v\nwant %v", m, want)
+ }
+}
+
+func TestMapParsing(t *testing.T) {
+ m := new(pb2.MessageWithMap)
+ const in = `name_mapping:<key:1234 value:"Feist"> name_mapping:<key:1 value:"Beatles">` +
+ `msg_mapping:<key:-4, value:<f: 2.0>,>` + // separating commas are okay
+ `msg_mapping<key:-2 value<f: 4.0>>` + // no colon after "value"
+ `msg_mapping:<value:<f: 5.0>>` + // omitted key
+ `byte_mapping:<key:true value:"so be it">` +
+ `byte_mapping:<>` // omitted key and value
+ want := &pb2.MessageWithMap{
+ NameMapping: map[int32]string{
+ 1: "Beatles",
+ 1234: "Feist",
+ },
+ MsgMapping: map[int64]*pb2.FloatingPoint{
+ -4: {F: proto.Float64(2.0)},
+ -2: {F: proto.Float64(4.0)},
+ 0: {F: proto.Float64(5.0)},
+ },
+ ByteMapping: map[bool][]byte{
+ false: nil,
+ true: []byte("so be it"),
+ },
+ }
+ if err := proto.UnmarshalText(in, m); err != nil {
+ t.Fatal(err)
+ }
+ if !proto.Equal(m, want) {
+ t.Errorf("proto.Equal mismatch:\ngot: %v\nwant %v", m, want)
+ }
+}
+
+func TestOneofParsing(t *testing.T) {
+ const in = `name:"Shrek"`
+ m := new(pb2.Communique)
+ want := &pb2.Communique{Union: &pb2.Communique_Name{"Shrek"}}
+ if err := proto.UnmarshalText(in, m); err != nil {
+ t.Fatal(err)
+ }
+ if !proto.Equal(m, want) {
+ t.Errorf("\n got %v\nwant %v", m, want)
+ }
+
+ const inOverwrite = `name:"Shrek" number:42`
+ m = new(pb2.Communique)
+ testErr := "line 1.13: field 'number' would overwrite already parsed oneof 'union'"
+ if err := proto.UnmarshalText(inOverwrite, m); err == nil {
+ t.Errorf("proto.UnmarshalText: got nil error, want %v", testErr)
+ } else if err.Error() != testErr {
+ t.Errorf("error mismatch:\ngot: %v\nwant: %v", err.Error(), testErr)
+ }
+}
