Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 buffer.go // 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 import ( "errors" "fmt" "google.golang.org/protobuf/encoding/prototext" "google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/runtime/protoimpl" ) const ( WireVarint = 0 WireFixed32 = 5 WireFixed64 = 1 WireBytes = 2 WireStartGroup = 3 WireEndGroup = 4 ) // EncodeVarint returns the varint encoded bytes of v. func EncodeVarint(v uint64) []byte { return protowire.AppendVarint(nil, v) } // SizeVarint returns the length of the varint encoded bytes of v. // This is equal to len(EncodeVarint(v)). func SizeVarint(v uint64) int { return protowire.SizeVarint(v) } // DecodeVarint parses a varint encoded integer from b, // returning the integer value and the length of the varint. // It returns (0, 0) if there is a parse error. func DecodeVarint(b []byte) (uint64, int) { v, n := protowire.ConsumeVarint(b) if n < 0 { return 0, 0 } return v, n } // Buffer is a buffer for encoding and decoding the protobuf wire format. // It may be reused between invocations to reduce memory usage. type Buffer struct { buf []byte idx int deterministic bool } // NewBuffer allocates a new Buffer initialized with buf, // where the contents of buf are considered the unread portion of the buffer. func NewBuffer(buf []byte) Buffer { return &Buffer{buf: buf} } // SetDeterministic specifies whether to use deterministic serialization. // // Deterministic serialization guarantees that for a given binary, equal // messages will always be serialized to the same bytes. This implies: // // - Repeated serialization of a message will return the same bytes. // - Different processes of the same binary (which may be executing on // different machines) will serialize equal messages to the same bytes. // // Note that the deterministic serialization is NOT canonical across // languages. It is not guaranteed to remain stable over time. It is unstable // across different builds with schema changes due to unknown fields. // Users who need canonical serialization (e.g., persistent storage in a // canonical form, fingerprinting, etc.) should define their own // canonicalization specification and implement their own serializer rather // than relying on this API. // // If deterministic serialization is requested, map entries will be sorted // by keys in lexographical order. This is an implementation detail and // subject to change. func (b Buffer) SetDeterministic(deterministic bool) { b.deterministic = deterministic } // SetBuf sets buf as the internal buffer, // where the contents of buf are considered the unread portion of the buffer. func (b Buffer) SetBuf(buf []byte) { b.buf = buf b.idx = 0 } // Reset clears the internal buffer of all written and unread data. func (b Buffer) Reset() { b.buf = b.buf[:0] b.idx = 0 } // Bytes returns the internal buffer. func (b Buffer) Bytes() []byte { return b.buf } // Unread returns the unread portion of the buffer. func (b Buffer) Unread() []byte { return b.buf[b.idx:] } // Marshal appends the wire-format encoding of m to the buffer. func (b Buffer) Marshal(m Message) error { var err error b.buf, err = marshalAppend(b.buf, m, b.deterministic) return err } // Unmarshal parses the wire-format message in the buffer and // places the decoded results in m. // It does not reset m before unmarshaling. func (b Buffer) Unmarshal(m Message) error { err := UnmarshalMerge(b.Unread(), m) b.idx = len(b.buf) return err } type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields } func (m unknownFields) String() string { panic("not implemented") } func (m unknownFields) Reset() { panic("not implemented") } func (m unknownFields) ProtoMessage() { panic("not implemented") } // DebugPrint dumps the encoded bytes of b with a header and footer including s // to stdout. This is only intended for debugging. func (Buffer) DebugPrint(s string, b []byte) { m := MessageReflect(new(unknownFields)) m.SetUnknown(b) b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface()) fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s) } // EncodeVarint appends an unsigned varint encoding to the buffer. func (b Buffer) EncodeVarint(v uint64) error { b.buf = protowire.AppendVarint(b.buf, v) return nil } // EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer. func (b Buffer) EncodeZigzag32(v uint64) error { return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31)))) } // EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer. func (b Buffer) EncodeZigzag64(v uint64) error { return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63)))) } // EncodeFixed32 appends a 32-bit little-endian integer to the buffer. func (b Buffer) EncodeFixed32(v uint64) error { b.buf = protowire.AppendFixed32(b.buf, uint32(v)) return nil } // EncodeFixed64 appends a 64-bit little-endian integer to the buffer. func (b Buffer) EncodeFixed64(v uint64) error { b.buf = protowire.AppendFixed64(b.buf, uint64(v)) return nil } // EncodeRawBytes appends a length-prefixed raw bytes to the buffer. func (b Buffer) EncodeRawBytes(v []byte) error { b.buf = protowire.AppendBytes(b.buf, v) return nil } // EncodeStringBytes appends a length-prefixed raw bytes to the buffer. // It does not validate whether v contains valid UTF-8. func (b Buffer) EncodeStringBytes(v string) error { b.buf = protowire.AppendString(b.buf, v) return nil } // EncodeMessage appends a length-prefixed encoded message to the buffer. func (b Buffer) EncodeMessage(m Message) error { var err error b.buf = protowire.AppendVarint(b.buf, uint64(Size(m))) b.buf, err = marshalAppend(b.buf, m, b.deterministic) return err } // DecodeVarint consumes an encoded unsigned varint from the buffer. func (b Buffer) DecodeVarint() (uint64, error) { v, n := protowire.ConsumeVarint(b.buf[b.idx:]) if n < 0 { return 0, protowire.ParseError(n) } b.idx += n return uint64(v), nil } // DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer. func (b Buffer) DecodeZigzag32() (uint64, error) { v, err := b.DecodeVarint() if err != nil { return 0, err } return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil } // DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer. func (b Buffer) DecodeZigzag64() (uint64, error) { v, err := b.DecodeVarint() if err != nil { return 0, err } return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil } // DecodeFixed32 consumes a 32-bit little-endian integer from the buffer. func (b Buffer) DecodeFixed32() (uint64, error) { v, n := protowire.ConsumeFixed32(b.buf[b.idx:]) if n < 0 { return 0, protowire.ParseError(n) } b.idx += n return uint64(v), nil } // DecodeFixed64 consumes a 64-bit little-endian integer from the buffer. func (b Buffer) DecodeFixed64() (uint64, error) { v, n := protowire.ConsumeFixed64(b.buf[b.idx:]) if n < 0 { return 0, protowire.ParseError(n) } b.idx += n return uint64(v), nil } // DecodeRawBytes consumes a length-prefixed raw bytes from the buffer. // If alloc is specified, it returns a copy the raw bytes // rather than a sub-slice of the buffer. func (b Buffer) DecodeRawBytes(alloc bool) ([]byte, error) { v, n := protowire.ConsumeBytes(b.buf[b.idx:]) if n < 0 { return nil, protowire.ParseError(n) } b.idx += n if alloc { v = append([]byte(nil), v...) } return v, nil } // DecodeStringBytes consumes a length-prefixed raw bytes from the buffer. // It does not validate whether the raw bytes contain valid UTF-8. func (b Buffer) DecodeStringBytes() (string, error) { v, n := protowire.ConsumeString(b.buf[b.idx:]) if n < 0 { return "", protowire.ParseError(n) } b.idx += n return v, nil } // DecodeMessage consumes a length-prefixed message from the buffer. // It does not reset m before unmarshaling. func (b Buffer) DecodeMessage(m Message) error { v, err := b.DecodeRawBytes(false) if err != nil { return err } return UnmarshalMerge(v, m) } // DecodeGroup consumes a message group from the buffer. // It assumes that the start group marker has already been consumed and // consumes all bytes until (and including the end group marker). // It does not reset m before unmarshaling. func (b *Buffer) DecodeGroup(m Message) error { v, n, err := consumeGroup(b.buf[b.idx:]) if err != nil { return err } b.idx += n return UnmarshalMerge(v, m) } // consumeGroup parses b until it finds an end group marker, returning // the raw bytes of the message (excluding the end group marker) and the // the total length of the message (including the end group marker). func consumeGroup(b []byte) ([]byte, int, error) { b0 := b depth := 1 // assume this follows a start group marker for { _, wtyp, tagLen := protowire.ConsumeTag(b) if tagLen < 0 { return nil, 0, protowire.ParseError(tagLen) } b = b[tagLen:] var valLen int switch wtyp { case protowire.VarintType: _, valLen = protowire.ConsumeVarint(b) case protowire.Fixed32Type: _, valLen = protowire.ConsumeFixed32(b) case protowire.Fixed64Type: _, valLen = protowire.ConsumeFixed64(b) case protowire.BytesType: _, valLen = protowire.ConsumeBytes(b) case protowire.StartGroupType: depth++ case protowire.EndGroupType: depth-- default: return nil, 0, errors.New("proto: cannot parse reserved wire type") } if valLen < 0 { return nil, 0, protowire.ParseError(valLen) } b = b[valLen:] if depth == 0 { return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil } } }	9.56 KB	2025-05-25 12:27
📄 defaults.go // 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 import ( "google.golang.org/protobuf/reflect/protoreflect" ) // SetDefaults sets unpopulated scalar fields to their default values. // Fields within a oneof are not set even if they have a default value. // SetDefaults is recursively called upon any populated message fields. func SetDefaults(m Message) { if m != nil { setDefaults(MessageReflect(m)) } } func setDefaults(m protoreflect.Message) { fds := m.Descriptor().Fields() for i := 0; i < fds.Len(); i++ { fd := fds.Get(i) if !m.Has(fd) { if fd.HasDefault() && fd.ContainingOneof() == nil { v := fd.Default() if fd.Kind() == protoreflect.BytesKind { v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes } m.Set(fd, v) } continue } } m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { switch { // Handle singular message. case fd.Cardinality() != protoreflect.Repeated: if fd.Message() != nil { setDefaults(m.Get(fd).Message()) } // Handle list of messages. case fd.IsList(): if fd.Message() != nil { ls := m.Get(fd).List() for i := 0; i < ls.Len(); i++ { setDefaults(ls.Get(i).Message()) } } // Handle map of messages. case fd.IsMap(): if fd.MapValue().Message() != nil { ms := m.Get(fd).Map() ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool { setDefaults(v.Message()) return true }) } } return true }) }	1.6 KB	2025-05-25 12:27
📄 deprecated.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 proto import ( "encoding/json" "errors" "fmt" "strconv" protoV2 "google.golang.org/protobuf/proto" ) var ( // Deprecated: No longer returned. ErrNil = errors.New("proto: Marshal called with nil") // Deprecated: No longer returned. ErrTooLarge = errors.New("proto: message encodes to over 2 GB") // Deprecated: No longer returned. ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") ) // Deprecated: Do not use. type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 } // Deprecated: Do not use. func GetStats() Stats { return Stats{} } // Deprecated: Do not use. func MarshalMessageSet(interface{}) ([]byte, error) { return nil, errors.New("proto: not implemented") } // Deprecated: Do not use. func UnmarshalMessageSet([]byte, interface{}) error { return errors.New("proto: not implemented") } // Deprecated: Do not use. func MarshalMessageSetJSON(interface{}) ([]byte, error) { return nil, errors.New("proto: not implemented") } // Deprecated: Do not use. func UnmarshalMessageSetJSON([]byte, interface{}) error { return errors.New("proto: not implemented") } // Deprecated: Do not use. func RegisterMessageSetType(Message, int32, string) {} // Deprecated: Do not use. func EnumName(m map[int32]string, v int32) string { s, ok := m[v] if ok { return s } return strconv.Itoa(int(v)) } // Deprecated: Do not use. func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { if data[0] == '"' { // New style: enums are strings. var repr string if err := json.Unmarshal(data, &repr); err != nil { return -1, err } val, ok := m[repr] if !ok { return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) } return val, nil } // Old style: enums are ints. var val int32 if err := json.Unmarshal(data, &val); err != nil { return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) } return val, nil } // Deprecated: Do not use; this type existed for intenal-use only. type InternalMessageInfo struct{} // Deprecated: Do not use; this method existed for intenal-use only. func (InternalMessageInfo) DiscardUnknown(m Message) { DiscardUnknown(m) } // Deprecated: Do not use; this method existed for intenal-use only. func (InternalMessageInfo) Marshal(b []byte, m Message, deterministic bool) ([]byte, error) { return protoV2.MarshalOptions{Deterministic: deterministic}.MarshalAppend(b, MessageV2(m)) } // Deprecated: Do not use; this method existed for intenal-use only. func (InternalMessageInfo) Merge(dst, src Message) { protoV2.Merge(MessageV2(dst), MessageV2(src)) } // Deprecated: Do not use; this method existed for intenal-use only. func (InternalMessageInfo) Size(m Message) int { return protoV2.Size(MessageV2(m)) } // Deprecated: Do not use; this method existed for intenal-use only. func (*InternalMessageInfo) Unmarshal(m Message, b []byte) error { return protoV2.UnmarshalOptions{Merge: true}.Unmarshal(b, MessageV2(m)) }	3.11 KB	2025-05-25 12:27
📄 discard.go // 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 import ( "google.golang.org/protobuf/reflect/protoreflect" ) // DiscardUnknown recursively discards all unknown fields from this message // and all embedded messages. // // When unmarshaling a message with unrecognized fields, the tags and values // of such fields are preserved in the Message. This allows a later call to // marshal to be able to produce a message that continues to have those // unrecognized fields. To avoid this, DiscardUnknown is used to // explicitly clear the unknown fields after unmarshaling. func DiscardUnknown(m Message) { if m != nil { discardUnknown(MessageReflect(m)) } } func discardUnknown(m protoreflect.Message) { m.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool { switch { // Handle singular message. case fd.Cardinality() != protoreflect.Repeated: if fd.Message() != nil { discardUnknown(m.Get(fd).Message()) } // Handle list of messages. case fd.IsList(): if fd.Message() != nil { ls := m.Get(fd).List() for i := 0; i < ls.Len(); i++ { discardUnknown(ls.Get(i).Message()) } } // Handle map of messages. case fd.IsMap(): if fd.MapValue().Message() != nil { ms := m.Get(fd).Map() ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool { discardUnknown(v.Message()) return true }) } } return true }) // Discard unknown fields. if len(m.GetUnknown()) > 0 { m.SetUnknown(nil) } }	1.58 KB	2025-05-25 12:27
📄 discard_test.go // Copyright 2017 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 ( "testing" "github.com/golang/protobuf/proto" "google.golang.org/protobuf/testing/protopack" pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto" pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto" ) var rawFields = protopack.Message{ protopack.Tag{5, protopack.Fixed32Type}, protopack.Uint32(4041331395), }.Marshal() func TestDiscardUnknown(t testing.T) { tests := []struct { desc string in, want proto.Message }{{ desc: "Nil", in: nil, want: nil, // Should not panic }, { desc: "NilPtr", in: (pb3.Message)(nil), want: (pb3.Message)(nil), // Should not panic }, { desc: "Nested", in: &pb3.Message{ Name: "Aaron", Nested: &pb3.Nested{Cute: true, XXX_unrecognized: []byte(rawFields)}, XXX_unrecognized: []byte(rawFields), }, want: &pb3.Message{ Name: "Aaron", Nested: &pb3.Nested{Cute: true}, }, }, { desc: "Slice", in: &pb3.Message{ Name: "Aaron", Children: []pb3.Message{ {Name: "Sarah", XXX_unrecognized: []byte(rawFields)}, {Name: "Abraham", XXX_unrecognized: []byte(rawFields)}, }, XXX_unrecognized: []byte(rawFields), }, want: &pb3.Message{ Name: "Aaron", Children: []pb3.Message{ {Name: "Sarah"}, {Name: "Abraham"}, }, }, }, { desc: "OneOf", in: &pb2.Communique{ Union: &pb2.Communique_Msg{&pb2.Strings{ StringField: proto.String("123"), XXX_unrecognized: []byte(rawFields), }}, XXX_unrecognized: []byte(rawFields), }, want: &pb2.Communique{ Union: &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("123")}}, }, }, { desc: "Map", in: &pb2.MessageWithMap{MsgMapping: map[int64]pb2.FloatingPoint{ 0x4002: &pb2.FloatingPoint{ Exact: proto.Bool(true), XXX_unrecognized: []byte(rawFields), }, }}, want: &pb2.MessageWithMap{MsgMapping: map[int64]*pb2.FloatingPoint{ 0x4002: &pb2.FloatingPoint{Exact: proto.Bool(true)}, }}, }, { desc: "Extension", in: func() proto.Message { m := &pb2.MyMessage{ Count: proto.Int32(42), Somegroup: &pb2.MyMessage_SomeGroup{ GroupField: proto.Int32(6), XXX_unrecognized: []byte(rawFields), }, XXX_unrecognized: []byte(rawFields), } proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{ Data: proto.String("extension"), XXX_unrecognized: []byte(rawFields), }) return m }(), want: func() proto.Message { m := &pb2.MyMessage{ Count: proto.Int32(42), Somegroup: &pb2.MyMessage_SomeGroup{GroupField: proto.Int32(6)}, } proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("extension")}) return m }(), }} for _, tt := range tests { proto.DiscardUnknown(tt.in) if !proto.Equal(tt.in, tt.want) { t.Errorf("test %s, expected unknown fields to be discarded\ngot %v\nwant %v", tt.desc, tt.in, tt.want) } } }	3.01 KB	2025-05-25 12:27
📄 extensions.go // Copyright 2010 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 import ( "errors" "fmt" "reflect" "google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoimpl" ) type ( // ExtensionDesc represents an extension descriptor and // is used to interact with an extension field in a message. // // Variables of this type are generated in code by protoc-gen-go. ExtensionDesc = protoimpl.ExtensionInfo // ExtensionRange represents a range of message extensions. // Used in code generated by protoc-gen-go. ExtensionRange = protoiface.ExtensionRangeV1 // Deprecated: Do not use; this is an internal type. Extension = protoimpl.ExtensionFieldV1 // Deprecated: Do not use; this is an internal type. XXX_InternalExtensions = protoimpl.ExtensionFields ) // ErrMissingExtension reports whether the extension was not present. var ErrMissingExtension = errors.New("proto: missing extension") var errNotExtendable = errors.New("proto: not an extendable proto.Message") // HasExtension reports whether the extension field is present in m // either as an explicitly populated field or as an unknown field. func HasExtension(m Message, xt ExtensionDesc) (has bool) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() { return false } // Check whether any populated known field matches the field number. xtd := xt.TypeDescriptor() if isValidExtension(mr.Descriptor(), xtd) { has = mr.Has(xtd) } else { mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool { has = int32(fd.Number()) == xt.Field return !has }) } // Check whether any unknown field matches the field number. for b := mr.GetUnknown(); !has && len(b) > 0; { num, _, n := protowire.ConsumeField(b) has = int32(num) == xt.Field b = b[n:] } return has } // ClearExtension removes the extension field from m // either as an explicitly populated field or as an unknown field. func ClearExtension(m Message, xt ExtensionDesc) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() { return } xtd := xt.TypeDescriptor() if isValidExtension(mr.Descriptor(), xtd) { mr.Clear(xtd) } else { mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool { if int32(fd.Number()) == xt.Field { mr.Clear(fd) return false } return true }) } clearUnknown(mr, fieldNum(xt.Field)) } // ClearAllExtensions clears all extensions from m. // This includes populated fields and unknown fields in the extension range. func ClearAllExtensions(m Message) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() { return } mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool { if fd.IsExtension() { mr.Clear(fd) } return true }) clearUnknown(mr, mr.Descriptor().ExtensionRanges()) } // GetExtension retrieves a proto2 extended field from m. // // If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil), // then GetExtension parses the encoded field and returns a Go value of the specified type. // If the field is not present, then the default value is returned (if one is specified), // otherwise ErrMissingExtension is reported. // // If the descriptor is type incomplete (i.e., ExtensionDesc.ExtensionType is nil), // then GetExtension returns the raw encoded bytes for the extension field. func GetExtension(m Message, xt ExtensionDesc) (interface{}, error) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() \|\| mr.Descriptor().ExtensionRanges().Len() == 0 { return nil, errNotExtendable } // Retrieve the unknown fields for this extension field. var bo protoreflect.RawFields for bi := mr.GetUnknown(); len(bi) > 0; { num, _, n := protowire.ConsumeField(bi) if int32(num) == xt.Field { bo = append(bo, bi[:n]...) } bi = bi[n:] } // For type incomplete descriptors, only retrieve the unknown fields. if xt.ExtensionType == nil { return []byte(bo), nil } // If the extension field only exists as unknown fields, unmarshal it. // This is rarely done since proto.Unmarshal eagerly unmarshals extensions. xtd := xt.TypeDescriptor() if !isValidExtension(mr.Descriptor(), xtd) { return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m) } if !mr.Has(xtd) && len(bo) > 0 { m2 := mr.New() if err := (proto.UnmarshalOptions{ Resolver: extensionResolver{xt}, }.Unmarshal(bo, m2.Interface())); err != nil { return nil, err } if m2.Has(xtd) { mr.Set(xtd, m2.Get(xtd)) clearUnknown(mr, fieldNum(xt.Field)) } } // Check whether the message has the extension field set or a default. var pv protoreflect.Value switch { case mr.Has(xtd): pv = mr.Get(xtd) case xtd.HasDefault(): pv = xtd.Default() default: return nil, ErrMissingExtension } v := xt.InterfaceOf(pv) rv := reflect.ValueOf(v) if isScalarKind(rv.Kind()) { rv2 := reflect.New(rv.Type()) rv2.Elem().Set(rv) v = rv2.Interface() } return v, nil } // extensionResolver is a custom extension resolver that stores a single // extension type that takes precedence over the global registry. type extensionResolver struct{ xt protoreflect.ExtensionType } func (r extensionResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) { if xtd := r.xt.TypeDescriptor(); xtd.FullName() == field { return r.xt, nil } return protoregistry.GlobalTypes.FindExtensionByName(field) } func (r extensionResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) { if xtd := r.xt.TypeDescriptor(); xtd.ContainingMessage().FullName() == message && xtd.Number() == field { return r.xt, nil } return protoregistry.GlobalTypes.FindExtensionByNumber(message, field) } // GetExtensions returns a list of the extensions values present in m, // corresponding with the provided list of extension descriptors, xts. // If an extension is missing in m, the corresponding value is nil. func GetExtensions(m Message, xts []ExtensionDesc) ([]interface{}, error) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() { return nil, errNotExtendable } vs := make([]interface{}, len(xts)) for i, xt := range xts { v, err := GetExtension(m, xt) if err != nil { if err == ErrMissingExtension { continue } return vs, err } vs[i] = v } return vs, nil } // SetExtension sets an extension field in m to the provided value. func SetExtension(m Message, xt ExtensionDesc, v interface{}) error { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() \|\| mr.Descriptor().ExtensionRanges().Len() == 0 { return errNotExtendable } rv := reflect.ValueOf(v) if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) { return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType) } if rv.Kind() == reflect.Ptr { if rv.IsNil() { return fmt.Errorf("proto: SetExtension called with nil value of type %T", v) } if isScalarKind(rv.Elem().Kind()) { v = rv.Elem().Interface() } } xtd := xt.TypeDescriptor() if !isValidExtension(mr.Descriptor(), xtd) { return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m) } mr.Set(xtd, xt.ValueOf(v)) clearUnknown(mr, fieldNum(xt.Field)) return nil } // SetRawExtension inserts b into the unknown fields of m. // // Deprecated: Use Message.ProtoReflect.SetUnknown instead. func SetRawExtension(m Message, fnum int32, b []byte) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() { return } // Verify that the raw field is valid. for b0 := b; len(b0) > 0; { num, _, n := protowire.ConsumeField(b0) if int32(num) != fnum { panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum)) } b0 = b0[n:] } ClearExtension(m, &ExtensionDesc{Field: fnum}) mr.SetUnknown(append(mr.GetUnknown(), b...)) } // ExtensionDescs returns a list of extension descriptors found in m, // containing descriptors for both populated extension fields in m and // also unknown fields of m that are in the extension range. // For the later case, an type incomplete descriptor is provided where only // the ExtensionDesc.Field field is populated. // The order of the extension descriptors is undefined. func ExtensionDescs(m Message) ([]ExtensionDesc, error) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() \|\| mr.Descriptor().ExtensionRanges().Len() == 0 { return nil, errNotExtendable } // Collect a set of known extension descriptors. extDescs := make(map[protoreflect.FieldNumber]ExtensionDesc) mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { if fd.IsExtension() { xt := fd.(protoreflect.ExtensionTypeDescriptor) if xd, ok := xt.Type().(ExtensionDesc); ok { extDescs[fd.Number()] = xd } } return true }) // Collect a set of unknown extension descriptors. extRanges := mr.Descriptor().ExtensionRanges() for b := mr.GetUnknown(); len(b) > 0; { num, _, n := protowire.ConsumeField(b) if extRanges.Has(num) && extDescs[num] == nil { extDescs[num] = nil } b = b[n:] } // Transpose the set of descriptors into a list. var xts []ExtensionDesc for num, xt := range extDescs { if xt == nil { xt = &ExtensionDesc{Field: int32(num)} } xts = append(xts, xt) } return xts, nil } // isValidExtension reports whether xtd is a valid extension descriptor for md. func isValidExtension(md protoreflect.MessageDescriptor, xtd protoreflect.ExtensionTypeDescriptor) bool { return xtd.ContainingMessage() == md && md.ExtensionRanges().Has(xtd.Number()) } // isScalarKind reports whether k is a protobuf scalar kind (except bytes). // This function exists for historical reasons since the representation of // scalars differs between v1 and v2, where v1 uses T and v2 uses T. func isScalarKind(k reflect.Kind) bool { switch k { case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String: return true default: return false } } // clearUnknown removes unknown fields from m where remover.Has reports true. func clearUnknown(m protoreflect.Message, remover interface { Has(protoreflect.FieldNumber) bool }) { var bo protoreflect.RawFields for bi := m.GetUnknown(); len(bi) > 0; { num, _, n := protowire.ConsumeField(bi) if !remover.Has(num) { bo = append(bo, bi[:n]...) } bi = bi[n:] } if bi := m.GetUnknown(); len(bi) != len(bo) { m.SetUnknown(bo) } } type fieldNum protoreflect.FieldNumber func (n1 fieldNum) Has(n2 protoreflect.FieldNumber) bool { return protoreflect.FieldNumber(n1) == n2 }	10.69 KB	2025-05-25 12:27
📄 extensions_test.go // Copyright 2014 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" "fmt" "reflect" "sort" "strings" "sync" "testing" "github.com/golang/protobuf/proto" pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto" ) func TestGetExtensionsWithMissingExtensions(t testing.T) { msg := &pb2.MyMessage{} ext1 := &pb2.Ext{} if err := proto.SetExtension(msg, pb2.E_Ext_More, ext1); err != nil { t.Fatalf("Could not set ext1: %s", err) } exts, err := proto.GetExtensions(msg, []proto.ExtensionDesc{ pb2.E_Ext_More, pb2.E_Ext_Text, }) if err != nil { t.Fatalf("GetExtensions() failed: %s", err) } if exts[0] != ext1 { t.Errorf("ext1 not in returned extensions: %T %v", exts[0], exts[0]) } if exts[1] != nil { t.Errorf("ext2 in returned extensions: %T %v", exts[1], exts[1]) } } func TestGetExtensionForIncompleteDesc(t testing.T) { msg := &pb2.MyMessage{Count: proto.Int32(0)} extdesc1 := &proto.ExtensionDesc{ ExtendedType: (pb2.MyMessage)(nil), ExtensionType: (bool)(nil), Field: 123456789, Name: "a.b", Tag: "varint,123456789,opt", } ext1 := proto.Bool(true) if err := proto.SetExtension(msg, extdesc1, ext1); err != nil { t.Fatalf("Could not set ext1: %s", err) } extdesc2 := &proto.ExtensionDesc{ ExtendedType: (pb2.MyMessage)(nil), ExtensionType: ([]byte)(nil), Field: 123456790, Name: "a.c", Tag: "bytes,123456790,opt", } ext2 := []byte{0, 1, 2, 3, 4, 5, 6, 7} if err := proto.SetExtension(msg, extdesc2, ext2); err != nil { t.Fatalf("Could not set ext2: %s", err) } extdesc3 := &proto.ExtensionDesc{ ExtendedType: (pb2.MyMessage)(nil), ExtensionType: (pb2.Ext)(nil), Field: 123456791, Name: "a.d", Tag: "bytes,123456791,opt", } ext3 := &pb2.Ext{Data: proto.String("foo")} if err := proto.SetExtension(msg, extdesc3, ext3); err != nil { t.Fatalf("Could not set ext3: %s", err) } b, err := proto.Marshal(msg) if err != nil { t.Fatalf("Could not marshal msg: %v", err) } if err := proto.Unmarshal(b, msg); err != nil { t.Fatalf("Could not unmarshal into msg: %v", err) } var expected proto.Buffer if err := expected.EncodeVarint(uint64((extdesc1.Field << 3) \| proto.WireVarint)); err != nil { t.Fatalf("failed to compute expected prefix for ext1: %s", err) } if err := expected.EncodeVarint(1 /* bool true /); err != nil { t.Fatalf("failed to compute expected value for ext1: %s", err) } if b, err := proto.GetExtension(msg, &proto.ExtensionDesc{Field: extdesc1.Field}); err != nil { t.Fatalf("Failed to get raw value for ext1: %s", err) } else if !reflect.DeepEqual(b, expected.Bytes()) { t.Fatalf("Raw value for ext1: got %v, want %v", b, expected.Bytes()) } expected = proto.Buffer{} // reset if err := expected.EncodeVarint(uint64((extdesc2.Field << 3) \| proto.WireBytes)); err != nil { t.Fatalf("failed to compute expected prefix for ext2: %s", err) } if err := expected.EncodeRawBytes(ext2); err != nil { t.Fatalf("failed to compute expected value for ext2: %s", err) } if b, err := proto.GetExtension(msg, &proto.ExtensionDesc{Field: extdesc2.Field}); err != nil { t.Fatalf("Failed to get raw value for ext2: %s", err) } else if !reflect.DeepEqual(b, expected.Bytes()) { t.Fatalf("Raw value for ext2: got %v, want %v", b, expected.Bytes()) } expected = proto.Buffer{} // reset if err := expected.EncodeVarint(uint64((extdesc3.Field << 3) \| proto.WireBytes)); err != nil { t.Fatalf("failed to compute expected prefix for ext3: %s", err) } if b, err := proto.Marshal(ext3); err != nil { t.Fatalf("failed to compute expected value for ext3: %s", err) } else if err := expected.EncodeRawBytes(b); err != nil { t.Fatalf("failed to compute expected value for ext3: %s", err) } if b, err := proto.GetExtension(msg, &proto.ExtensionDesc{Field: extdesc3.Field}); err != nil { t.Fatalf("Failed to get raw value for ext3: %s", err) } else if !reflect.DeepEqual(b, expected.Bytes()) { t.Fatalf("Raw value for ext3: got %v, want %v", b, expected.Bytes()) } } func TestExtensionDescsWithUnregisteredExtensions(t testing.T) { msg := &pb2.MyMessage{Count: proto.Int32(0)} extdesc1 := pb2.E_Ext_More if descs, err := proto.ExtensionDescs(msg); len(descs) != 0 \|\| err != nil { t.Errorf("proto.ExtensionDescs: got %d descs, error %v; want 0, nil", len(descs), err) } ext1 := &pb2.Ext{} if err := proto.SetExtension(msg, extdesc1, ext1); err != nil { t.Fatalf("Could not set ext1: %s", err) } extdesc2 := &proto.ExtensionDesc{ ExtendedType: (pb2.MyMessage)(nil), ExtensionType: (bool)(nil), Field: 123456789, Name: "a.b", Tag: "varint,123456789,opt", } ext2 := proto.Bool(false) if err := proto.SetExtension(msg, extdesc2, ext2); err != nil { t.Fatalf("Could not set ext2: %s", err) } b, err := proto.Marshal(msg) if err != nil { t.Fatalf("Could not marshal msg: %v", err) } if err := proto.Unmarshal(b, msg); err != nil { t.Fatalf("Could not unmarshal into msg: %v", err) } descs, err := proto.ExtensionDescs(msg) if err != nil { t.Fatalf("proto.ExtensionDescs: got error %v", err) } sortExtDescs(descs) wantDescs := []proto.ExtensionDesc{extdesc1, {Field: extdesc2.Field}} if !reflect.DeepEqual(descs, wantDescs) { t.Errorf("proto.ExtensionDescs(msg) sorted extension ids: got %+v, want %+v", descs, wantDescs) } } type ExtensionDescSlice []proto.ExtensionDesc func (s ExtensionDescSlice) Len() int { return len(s) } func (s ExtensionDescSlice) Less(i, j int) bool { return s[i].Field < s[j].Field } func (s ExtensionDescSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func sortExtDescs(s []proto.ExtensionDesc) { sort.Sort(ExtensionDescSlice(s)) } func TestGetExtensionStability(t testing.T) { check := func(m pb2.MyMessage) bool { ext1, err := proto.GetExtension(m, pb2.E_Ext_More) if err != nil { t.Fatalf("GetExtension() failed: %s", err) } ext2, err := proto.GetExtension(m, pb2.E_Ext_More) if err != nil { t.Fatalf("GetExtension() failed: %s", err) } return ext1 == ext2 } msg := &pb2.MyMessage{Count: proto.Int32(4)} ext0 := &pb2.Ext{} if err := proto.SetExtension(msg, pb2.E_Ext_More, ext0); err != nil { t.Fatalf("Could not set ext1: %s", ext0) } if !check(msg) { t.Errorf("GetExtension() not stable before marshaling") } bb, err := proto.Marshal(msg) if err != nil { t.Fatalf("Marshal() failed: %s", err) } msg1 := &pb2.MyMessage{} err = proto.Unmarshal(bb, msg1) if err != nil { t.Fatalf("Unmarshal() failed: %s", err) } if !check(msg1) { t.Errorf("GetExtension() not stable after unmarshaling") } } func TestGetExtensionDefaults(t testing.T) { var setFloat64 float64 = 1 var setFloat32 float32 = 2 var setInt32 int32 = 3 var setInt64 int64 = 4 var setUint32 uint32 = 5 var setUint64 uint64 = 6 var setBool = true var setBool2 = false var setString = "Goodnight string" var setBytes = []byte("Goodnight bytes") var setEnum = pb2.DefaultsMessage_TWO type testcase struct { ext proto.ExtensionDesc // Extension we are testing. want interface{} // Expected value of extension, or nil (meaning that GetExtension will fail). def interface{} // Expected value of extension after ClearExtension(). } tests := []testcase{ {pb2.E_NoDefaultDouble, setFloat64, nil}, {pb2.E_NoDefaultFloat, setFloat32, nil}, {pb2.E_NoDefaultInt32, setInt32, nil}, {pb2.E_NoDefaultInt64, setInt64, nil}, {pb2.E_NoDefaultUint32, setUint32, nil}, {pb2.E_NoDefaultUint64, setUint64, nil}, {pb2.E_NoDefaultSint32, setInt32, nil}, {pb2.E_NoDefaultSint64, setInt64, nil}, {pb2.E_NoDefaultFixed32, setUint32, nil}, {pb2.E_NoDefaultFixed64, setUint64, nil}, {pb2.E_NoDefaultSfixed32, setInt32, nil}, {pb2.E_NoDefaultSfixed64, setInt64, nil}, {pb2.E_NoDefaultBool, setBool, nil}, {pb2.E_NoDefaultBool, setBool2, nil}, {pb2.E_NoDefaultString, setString, nil}, {pb2.E_NoDefaultBytes, setBytes, nil}, {pb2.E_NoDefaultEnum, setEnum, nil}, {pb2.E_DefaultDouble, setFloat64, float64(3.1415)}, {pb2.E_DefaultFloat, setFloat32, float32(3.14)}, {pb2.E_DefaultInt32, setInt32, int32(42)}, {pb2.E_DefaultInt64, setInt64, int64(43)}, {pb2.E_DefaultUint32, setUint32, uint32(44)}, {pb2.E_DefaultUint64, setUint64, uint64(45)}, {pb2.E_DefaultSint32, setInt32, int32(46)}, {pb2.E_DefaultSint64, setInt64, int64(47)}, {pb2.E_DefaultFixed32, setUint32, uint32(48)}, {pb2.E_DefaultFixed64, setUint64, uint64(49)}, {pb2.E_DefaultSfixed32, setInt32, int32(50)}, {pb2.E_DefaultSfixed64, setInt64, int64(51)}, {pb2.E_DefaultBool, setBool, true}, {pb2.E_DefaultBool, setBool2, true}, {pb2.E_DefaultString, setString, "Hello, string,def=foo"}, {pb2.E_DefaultBytes, setBytes, []byte("Hello, bytes")}, {pb2.E_DefaultEnum, setEnum, pb2.DefaultsMessage_ONE}, } checkVal := func(t testing.T, name string, test testcase, msg pb2.DefaultsMessage, valWant interface{}) { t.Run(name, func(t testing.T) { val, err := proto.GetExtension(msg, test.ext) if err != nil { if valWant != nil { t.Errorf("GetExtension(): %s", err) return } if want := proto.ErrMissingExtension; err != want { t.Errorf("Unexpected error: got %v, want %v", err, want) return } return } // All proto2 extension values are either a pointer to a value or a slice of values. ty := reflect.TypeOf(val) tyWant := reflect.TypeOf(test.ext.ExtensionType) if got, want := ty, tyWant; got != want { t.Errorf("unexpected reflect.TypeOf(): got %v want %v", got, want) return } tye := ty.Elem() tyeWant := tyWant.Elem() if got, want := tye, tyeWant; got != want { t.Errorf("unexpected reflect.TypeOf().Elem(): got %v want %v", got, want) return } // Check the name of the type of the value. // If it is an enum it will be type int32 with the name of the enum. if got, want := tye.Name(), tye.Name(); got != want { t.Errorf("unexpected reflect.TypeOf().Elem().Name(): got %v want %v", got, want) return } // Check that value is what we expect. // If we have a pointer in val, get the value it points to. valExp := val if ty.Kind() == reflect.Ptr { valExp = reflect.ValueOf(val).Elem().Interface() } if got, want := valExp, valWant; !reflect.DeepEqual(got, want) { t.Errorf("unexpected reflect.DeepEqual(): got %v want %v", got, want) return } }) } setTo := func(test testcase) interface{} { setTo := reflect.ValueOf(test.want) if typ := reflect.TypeOf(test.ext.ExtensionType); typ.Kind() == reflect.Ptr { setTo = reflect.New(typ).Elem() setTo.Set(reflect.New(setTo.Type().Elem())) setTo.Elem().Set(reflect.ValueOf(test.want)) } return setTo.Interface() } for _, test := range tests { msg := &pb2.DefaultsMessage{} name := test.ext.Name // Check the initial value. checkVal(t, name+"/initial", test, msg, test.def) // Set the per-type value and check value. if err := proto.SetExtension(msg, test.ext, setTo(test)); err != nil { t.Errorf("%s: SetExtension(): %v", name, err) continue } checkVal(t, name+"/set", test, msg, test.want) // Set and check the value. proto.ClearExtension(msg, test.ext) checkVal(t, name+"/cleared", test, msg, test.def) } } func TestNilMessage(t testing.T) { name := "nil interface" if got, err := proto.GetExtension(nil, pb2.E_Ext_More); err == nil { t.Errorf("%s: got %T %v, expected to fail", name, got, got) } else if !strings.Contains(err.Error(), "extendable") { t.Errorf("%s: got error %v, expected not-extendable error", name, err) } // Regression tests: all functions of the Extension API // used to panic when passed (M)(nil), where M is a concrete message // type. Now they handle this gracefully as a no-op or reported error. var nilMsg pb2.MyMessage desc := pb2.E_Ext_More isNotExtendable := func(err error) bool { return strings.Contains(fmt.Sprint(err), "not an extendable") } if proto.HasExtension(nilMsg, desc) { t.Error("HasExtension(nil) = true") } if _, err := proto.GetExtensions(nilMsg, []proto.ExtensionDesc{desc}); !isNotExtendable(err) { t.Errorf("GetExtensions(nil) = %q (wrong error)", err) } if _, err := proto.ExtensionDescs(nilMsg); !isNotExtendable(err) { t.Errorf("ExtensionDescs(nil) = %q (wrong error)", err) } if err := proto.SetExtension(nilMsg, desc, nil); !isNotExtendable(err) { t.Errorf("SetExtension(nil) = %q (wrong error)", err) } proto.ClearExtension(nilMsg, desc) // no-op proto.ClearAllExtensions(nilMsg) // no-op } func TestExtensionsRoundTrip(t testing.T) { msg := &pb2.MyMessage{} ext1 := &pb2.Ext{ Data: proto.String("hi"), } ext2 := &pb2.Ext{ Data: proto.String("there"), } exists := proto.HasExtension(msg, pb2.E_Ext_More) if exists { t.Error("Extension More present unexpectedly") } if err := proto.SetExtension(msg, pb2.E_Ext_More, ext1); err != nil { t.Error(err) } if err := proto.SetExtension(msg, pb2.E_Ext_More, ext2); err != nil { t.Error(err) } e, err := proto.GetExtension(msg, pb2.E_Ext_More) if err != nil { t.Error(err) } x, ok := e.(pb2.Ext) if !ok { t.Errorf("e has type %T, expected test_proto.Ext", e) } else if x.Data != "there" { t.Errorf("SetExtension failed to overwrite, got %+v, not 'there'", x) } proto.ClearExtension(msg, pb2.E_Ext_More) if _, err = proto.GetExtension(msg, pb2.E_Ext_More); err != proto.ErrMissingExtension { t.Errorf("got %v, expected ErrMissingExtension", e) } if err := proto.SetExtension(msg, pb2.E_Ext_More, 12); err == nil { t.Error("expected some sort of type mismatch error, got nil") } } func TestNilExtension(t testing.T) { msg := &pb2.MyMessage{ Count: proto.Int32(1), } if err := proto.SetExtension(msg, pb2.E_Ext_Text, proto.String("hello")); err != nil { t.Fatal(err) } if err := proto.SetExtension(msg, pb2.E_Ext_More, (pb2.Ext)(nil)); err == nil { t.Error("expected SetExtension to fail due to a nil extension") } else if want := fmt.Sprintf("proto: SetExtension called with nil value of type %T", new(pb2.Ext)); err.Error() != want { t.Errorf("expected error %v, got %v", want, err) } // Note: if the behavior of Marshal is ever changed to ignore nil extensions, update // this test to verify that E_Ext_Text is properly propagated through marshal->unmarshal. } func TestMarshalUnmarshalRepeatedExtension(t testing.T) { // Add a repeated extension to the result. tests := []struct { name string ext []pb2.ComplexExtension }{ { "two fields", []pb2.ComplexExtension{ {First: proto.Int32(7)}, {Second: proto.Int32(11)}, }, }, { "repeated field", []pb2.ComplexExtension{ {Third: []int32{1000}}, {Third: []int32{2000}}, }, }, { "two fields and repeated field", []pb2.ComplexExtension{ {Third: []int32{1000}}, {First: proto.Int32(9)}, {Second: proto.Int32(21)}, {Third: []int32{2000}}, }, }, } for _, test := range tests { // Marshal message with a repeated extension. msg1 := new(pb2.OtherMessage) err := proto.SetExtension(msg1, pb2.E_RComplex, test.ext) if err != nil { t.Fatalf("[%s] Error setting extension: %v", test.name, err) } b, err := proto.Marshal(msg1) if err != nil { t.Fatalf("[%s] Error marshaling message: %v", test.name, err) } // Unmarshal and read the merged proto. msg2 := new(pb2.OtherMessage) err = proto.Unmarshal(b, msg2) if err != nil { t.Fatalf("[%s] Error unmarshaling message: %v", test.name, err) } e, err := proto.GetExtension(msg2, pb2.E_RComplex) if err != nil { t.Fatalf("[%s] Error getting extension: %v", test.name, err) } ext := e.([]pb2.ComplexExtension) if ext == nil { t.Fatalf("[%s] Invalid extension", test.name) } if len(ext) != len(test.ext) { t.Errorf("[%s] Wrong length of ComplexExtension: got: %v want: %v\n", test.name, len(ext), len(test.ext)) } for i := range test.ext { if !proto.Equal(ext[i], test.ext[i]) { t.Errorf("[%s] Wrong value for ComplexExtension[%d]: got: %v want: %v\n", test.name, i, ext[i], test.ext[i]) } } } } func TestUnmarshalRepeatingNonRepeatedExtension(t testing.T) { // We may see multiple instances of the same extension in the wire // format. For example, the proto compiler may encode custom options in // this way. Here, we verify that we merge the extensions together. tests := []struct { name string ext []pb2.ComplexExtension }{ { "two fields", []pb2.ComplexExtension{ {First: proto.Int32(7)}, {Second: proto.Int32(11)}, }, }, { "repeated field", []pb2.ComplexExtension{ {Third: []int32{1000}}, {Third: []int32{2000}}, }, }, { "two fields and repeated field", []pb2.ComplexExtension{ {Third: []int32{1000}}, {First: proto.Int32(9)}, {Second: proto.Int32(21)}, {Third: []int32{2000}}, }, }, } for _, test := range tests { var buf bytes.Buffer var want pb2.ComplexExtension // Generate a serialized representation of a repeated extension // by catenating bytes together. for i, e := range test.ext { // Merge to create the wanted proto. proto.Merge(&want, e) // serialize the message msg := new(pb2.OtherMessage) err := proto.SetExtension(msg, pb2.E_Complex, e) if err != nil { t.Fatalf("[%s] Error setting extension %d: %v", test.name, i, err) } b, err := proto.Marshal(msg) if err != nil { t.Fatalf("[%s] Error marshaling message %d: %v", test.name, i, err) } buf.Write(b) } // Unmarshal and read the merged proto. msg2 := new(pb2.OtherMessage) err := proto.Unmarshal(buf.Bytes(), msg2) if err != nil { t.Fatalf("[%s] Error unmarshaling message: %v", test.name, err) } e, err := proto.GetExtension(msg2, pb2.E_Complex) if err != nil { t.Fatalf("[%s] Error getting extension: %v", test.name, err) } ext := e.(pb2.ComplexExtension) if ext == nil { t.Fatalf("[%s] Invalid extension", test.name) } if !proto.Equal(ext, &want) { t.Errorf("[%s] Wrong value for ComplexExtension: got: %s want: %s\n", test.name, ext, &want) } } } func TestClearAllExtensions(t testing.T) { // unregistered extension desc := &proto.ExtensionDesc{ ExtendedType: (pb2.MyMessage)(nil), ExtensionType: (bool)(nil), Field: 101010100, Name: "emptyextension", Tag: "varint,0,opt", } m := &pb2.MyMessage{} if proto.HasExtension(m, desc) { t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m)) } if err := proto.SetExtension(m, desc, proto.Bool(true)); err != nil { t.Errorf("proto.SetExtension(m, desc, true): got error %q, want nil", err) } if !proto.HasExtension(m, desc) { t.Errorf("proto.HasExtension(%s): got false, want true", proto.MarshalTextString(m)) } proto.ClearAllExtensions(m) if proto.HasExtension(m, desc) { t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m)) } } func TestMarshalRace(t *testing.T) { ext := &pb2.Ext{} m := &pb2.MyMessage{Count: proto.Int32(4)} if err := proto.SetExtension(m, pb2.E_Ext_More, ext); err != nil { t.Fatalf("proto.SetExtension(m, desc, true): got error %q, want nil", err) } b, err := proto.Marshal(m) if err != nil { t.Fatalf("Could not marshal message: %v", err) } if err := proto.Unmarshal(b, m); err != nil { t.Fatalf("Could not unmarshal message: %v", err) } // after Unmarshal, the extension is in undecoded form. // GetExtension will decode it lazily. Make sure this does // not race against Marshal. wg := sync.WaitGroup{} errs := make(chan error, 3) for n := 3; n > 0; n-- { wg.Add(1) go func() { defer wg.Done() _, err := proto.Marshal(m) errs <- err }() } wg.Wait() close(errs) for err = range errs { if err != nil { t.Fatal(err) } } }	19.6 KB	2025-05-25 12:27
📄 properties.go // Copyright 2010 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 import ( "fmt" "reflect" "strconv" "strings" "sync" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/runtime/protoimpl" ) // StructProperties represents protocol buffer type information for a // generated protobuf message in the open-struct API. // // Deprecated: Do not use. type StructProperties struct { // Prop are the properties for each field. // // Fields belonging to a oneof are stored in OneofTypes instead, with a // single Properties representing the parent oneof held here. // // The order of Prop matches the order of fields in the Go struct. // Struct fields that are not related to protobufs have a "XXX_" prefix // in the Properties.Name and must be ignored by the user. Prop []Properties // OneofTypes contains information about the oneof fields in this message. // It is keyed by the protobuf field name. OneofTypes map[string]OneofProperties } // Properties represents the type information for a protobuf message field. // // Deprecated: Do not use. type Properties struct { // Name is a placeholder name with little meaningful semantic value. // If the name has an "XXX_" prefix, the entire Properties must be ignored. Name string // OrigName is the protobuf field name or oneof name. OrigName string // JSONName is the JSON name for the protobuf field. JSONName string // Enum is a placeholder name for enums. // For historical reasons, this is neither the Go name for the enum, // nor the protobuf name for the enum. Enum string // Deprecated: Do not use. // Weak contains the full name of the weakly referenced message. Weak string // Wire is a string representation of the wire type. Wire string // WireType is the protobuf wire type for the field. WireType int // Tag is the protobuf field number. Tag int // Required reports whether this is a required field. Required bool // Optional reports whether this is a optional field. Optional bool // Repeated reports whether this is a repeated field. Repeated bool // Packed reports whether this is a packed repeated field of scalars. Packed bool // Proto3 reports whether this field operates under the proto3 syntax. Proto3 bool // Oneof reports whether this field belongs within a oneof. Oneof bool // Default is the default value in string form. Default string // HasDefault reports whether the field has a default value. HasDefault bool // MapKeyProp is the properties for the key field for a map field. MapKeyProp Properties // MapValProp is the properties for the value field for a map field. MapValProp Properties } // OneofProperties represents the type information for a protobuf oneof. // // Deprecated: Do not use. type OneofProperties struct { // Type is a pointer to the generated wrapper type for the field value. // This is nil for messages that are not in the open-struct API. Type reflect.Type // Field is the index into StructProperties.Prop for the containing oneof. Field int // Prop is the properties for the field. Prop Properties } // String formats the properties in the protobuf struct field tag style. func (p Properties) String() string { s := p.Wire s += "," + strconv.Itoa(p.Tag) if p.Required { s += ",req" } if p.Optional { s += ",opt" } if p.Repeated { s += ",rep" } if p.Packed { s += ",packed" } s += ",name=" + p.OrigName if p.JSONName != "" { s += ",json=" + p.JSONName } if len(p.Enum) > 0 { s += ",enum=" + p.Enum } if len(p.Weak) > 0 { s += ",weak=" + p.Weak } if p.Proto3 { s += ",proto3" } if p.Oneof { s += ",oneof" } if p.HasDefault { s += ",def=" + p.Default } return s } // Parse populates p by parsing a string in the protobuf struct field tag style. func (p Properties) Parse(tag string) { // For example: "bytes,49,opt,name=foo,def=hello!" for len(tag) > 0 { i := strings.IndexByte(tag, ',') if i < 0 { i = len(tag) } switch s := tag[:i]; { case strings.HasPrefix(s, "name="): p.OrigName = s[len("name="):] case strings.HasPrefix(s, "json="): p.JSONName = s[len("json="):] case strings.HasPrefix(s, "enum="): p.Enum = s[len("enum="):] case strings.HasPrefix(s, "weak="): p.Weak = s[len("weak="):] case strings.Trim(s, "0123456789") == "": n, _ := strconv.ParseUint(s, 10, 32) p.Tag = int(n) case s == "opt": p.Optional = true case s == "req": p.Required = true case s == "rep": p.Repeated = true case s == "varint" \|\| s == "zigzag32" \|\| s == "zigzag64": p.Wire = s p.WireType = WireVarint case s == "fixed32": p.Wire = s p.WireType = WireFixed32 case s == "fixed64": p.Wire = s p.WireType = WireFixed64 case s == "bytes": p.Wire = s p.WireType = WireBytes case s == "group": p.Wire = s p.WireType = WireStartGroup case s == "packed": p.Packed = true case s == "proto3": p.Proto3 = true case s == "oneof": p.Oneof = true case strings.HasPrefix(s, "def="): // The default tag is special in that everything afterwards is the // default regardless of the presence of commas. p.HasDefault = true p.Default, i = tag[len("def="):], len(tag) } tag = strings.TrimPrefix(tag[i:], ",") } } // Init populates the properties from a protocol buffer struct tag. // // Deprecated: Do not use. func (p Properties) Init(typ reflect.Type, name, tag string, f reflect.StructField) { p.Name = name p.OrigName = name if tag == "" { return } p.Parse(tag) if typ != nil && typ.Kind() == reflect.Map { p.MapKeyProp = new(Properties) p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil) p.MapValProp = new(Properties) p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil) } } var propertiesCache sync.Map // map[reflect.Type]StructProperties // GetProperties returns the list of properties for the type represented by t, // which must be a generated protocol buffer message in the open-struct API, // where protobuf message fields are represented by exported Go struct fields. // // Deprecated: Use protobuf reflection instead. func GetProperties(t reflect.Type) StructProperties { if p, ok := propertiesCache.Load(t); ok { return p.(StructProperties) } p, _ := propertiesCache.LoadOrStore(t, newProperties(t)) return p.(StructProperties) } func newProperties(t reflect.Type) StructProperties { if t.Kind() != reflect.Struct { panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t)) } var hasOneof bool prop := new(StructProperties) // Construct a list of properties for each field in the struct. for i := 0; i < t.NumField(); i++ { p := new(Properties) f := t.Field(i) tagField := f.Tag.Get("protobuf") p.Init(f.Type, f.Name, tagField, &f) tagOneof := f.Tag.Get("protobuf_oneof") if tagOneof != "" { hasOneof = true p.OrigName = tagOneof } // Rename unrelated struct fields with the "XXX_" prefix since so much // user code simply checks for this to exclude special fields. if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") { p.Name = "XXX_" + p.Name p.OrigName = "XXX_" + p.OrigName } else if p.Weak != "" { p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field } prop.Prop = append(prop.Prop, p) } // Construct a mapping of oneof field names to properties. if hasOneof { var oneofWrappers []interface{} if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok { oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{}) } if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok { oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{}) } if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok { if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() protoimpl.MessageInfo }); ok { oneofWrappers = m.ProtoMessageInfo().OneofWrappers } } prop.OneofTypes = make(map[string]OneofProperties) for _, wrapper := range oneofWrappers { p := &OneofProperties{ Type: reflect.ValueOf(wrapper).Type(), // T Prop: new(Properties), } f := p.Type.Elem().Field(0) p.Prop.Name = f.Name p.Prop.Parse(f.Tag.Get("protobuf")) // Determine the struct field that contains this oneof. // Each wrapper is assignable to exactly one parent field. var foundOneof bool for i := 0; i < t.NumField() && !foundOneof; i++ { if p.Type.AssignableTo(t.Field(i).Type) { p.Field = i foundOneof = true } } if !foundOneof { panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t)) } prop.OneofTypes[p.Prop.OrigName] = p } } return prop } func (sp StructProperties) Len() int { return len(sp.Prop) } func (sp StructProperties) Less(i, j int) bool { return false } func (sp StructProperties) Swap(i, j int) { return }	8.89 KB	2025-05-25 12:27
📄 proto.go // 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 provides functionality for handling protocol buffer messages. // In particular, it provides marshaling and unmarshaling between a protobuf // message and the binary wire format. // // See https://developers.google.com/protocol-buffers/docs/gotutorial for // more information. // // Deprecated: Use the "google.golang.org/protobuf/proto" package instead. package proto import ( protoV2 "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoimpl" ) const ( ProtoPackageIsVersion1 = true ProtoPackageIsVersion2 = true ProtoPackageIsVersion3 = true ProtoPackageIsVersion4 = true ) // GeneratedEnum is any enum type generated by protoc-gen-go // which is a named int32 kind. // This type exists for documentation purposes. type GeneratedEnum interface{} // GeneratedMessage is any message type generated by protoc-gen-go // which is a pointer to a named struct kind. // This type exists for documentation purposes. type GeneratedMessage interface{} // Message is a protocol buffer message. // // This is the v1 version of the message interface and is marginally better // than an empty interface as it lacks any method to programatically interact // with the contents of the message. // // A v2 message is declared in "google.golang.org/protobuf/proto".Message and // exposes protobuf reflection as a first-class feature of the interface. // // To convert a v1 message to a v2 message, use the MessageV2 function. // To convert a v2 message to a v1 message, use the MessageV1 function. type Message = protoiface.MessageV1 // MessageV1 converts either a v1 or v2 message to a v1 message. // It returns nil if m is nil. func MessageV1(m GeneratedMessage) protoiface.MessageV1 { return protoimpl.X.ProtoMessageV1Of(m) } // MessageV2 converts either a v1 or v2 message to a v2 message. // It returns nil if m is nil. func MessageV2(m GeneratedMessage) protoV2.Message { return protoimpl.X.ProtoMessageV2Of(m) } // MessageReflect returns a reflective view for a message. // It returns nil if m is nil. func MessageReflect(m Message) protoreflect.Message { return protoimpl.X.MessageOf(m) } // Marshaler is implemented by messages that can marshal themselves. // This interface is used by the following functions: Size, Marshal, // Buffer.Marshal, and Buffer.EncodeMessage. // // Deprecated: Do not implement. type Marshaler interface { // Marshal formats the encoded bytes of the message. // It should be deterministic and emit valid protobuf wire data. // The caller takes ownership of the returned buffer. Marshal() ([]byte, error) } // Unmarshaler is implemented by messages that can unmarshal themselves. // This interface is used by the following functions: Unmarshal, UnmarshalMerge, // Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup. // // Deprecated: Do not implement. type Unmarshaler interface { // Unmarshal parses the encoded bytes of the protobuf wire input. // The provided buffer is only valid for during method call. // It should not reset the receiver message. Unmarshal([]byte) error } // Merger is implemented by messages that can merge themselves. // This interface is used by the following functions: Clone and Merge. // // Deprecated: Do not implement. type Merger interface { // Merge merges the contents of src into the receiver message. // It clones all data structures in src such that it aliases no mutable // memory referenced by src. Merge(src Message) } // RequiredNotSetError is an error type returned when // marshaling or unmarshaling a message with missing required fields. type RequiredNotSetError struct { err error } func (e RequiredNotSetError) Error() string { if e.err != nil { return e.err.Error() } return "proto: required field not set" } func (e RequiredNotSetError) RequiredNotSet() bool { return true } func checkRequiredNotSet(m protoV2.Message) error { if err := protoV2.CheckInitialized(m); err != nil { return &RequiredNotSetError{err: err} } return nil } // Clone returns a deep copy of src. func Clone(src Message) Message { return MessageV1(protoV2.Clone(MessageV2(src))) } // Merge merges src into dst, which must be messages of the same type. // // Populated scalar fields in src are copied to dst, while populated // singular messages in src are merged into dst by recursively calling Merge. // The elements of every list field in src is appended to the corresponded // list fields in dst. The entries of every map field in src is copied into // the corresponding map field in dst, possibly replacing existing entries. // The unknown fields of src are appended to the unknown fields of dst. func Merge(dst, src Message) { protoV2.Merge(MessageV2(dst), MessageV2(src)) } // Equal reports whether two messages are equal. // If two messages marshal to the same bytes under deterministic serialization, // then Equal is guaranteed to report true. // // Two messages are equal if they are the same protobuf message type, // have the same set of populated known and extension field values, // and the same set of unknown fields values. // // Scalar values are compared with the equivalent of the == operator in Go, // except bytes values which are compared using bytes.Equal and // floating point values which specially treat NaNs as equal. // Message values are compared by recursively calling Equal. // Lists are equal if each element value is also equal. // Maps are equal if they have the same set of keys, where the pair of values // for each key is also equal. func Equal(x, y Message) bool { return protoV2.Equal(MessageV2(x), MessageV2(y)) } func isMessageSet(md protoreflect.MessageDescriptor) bool { ms, ok := md.(interface{ IsMessageSet() bool }) return ok && ms.IsMessageSet() }	5.86 KB	2025-05-25 12:27
📄 proto_clone_test.go // Copyright 2011 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 ( "testing" "github.com/golang/protobuf/proto" pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto" pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto" ) var cloneTestMessage = &pb2.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), Pet: []string{"bunny", "kitty", "horsey"}, Inner: &pb2.InnerMessage{ Host: proto.String("niles"), Port: proto.Int32(9099), Connected: proto.Bool(true), }, Others: []pb2.OtherMessage{ { Value: []byte("some bytes"), }, }, Somegroup: &pb2.MyMessage_SomeGroup{ GroupField: proto.Int32(6), }, RepBytes: [][]byte{[]byte("sham"), []byte("wow")}, } func init() { ext := &pb2.Ext{ Data: proto.String("extension"), } if err := proto.SetExtension(cloneTestMessage, pb2.E_Ext_More, ext); err != nil { panic("SetExtension: " + err.Error()) } if err := proto.SetExtension(cloneTestMessage, pb2.E_Ext_Text, proto.String("hello")); err != nil { panic("SetExtension: " + err.Error()) } if err := proto.SetExtension(cloneTestMessage, pb2.E_Greeting, []string{"one", "two"}); err != nil { panic("SetExtension: " + err.Error()) } } func TestClone(t testing.T) { // Create a clone using a marshal/unmarshal roundtrip. vanilla := new(pb2.MyMessage) b, err := proto.Marshal(cloneTestMessage) if err != nil { t.Errorf("unexpected Marshal error: %v", err) } if err := proto.Unmarshal(b, vanilla); err != nil { t.Errorf("unexpected Unarshal error: %v", err) } // Create a clone using Clone and verify that it is equal to the original. m := proto.Clone(cloneTestMessage).(pb2.MyMessage) if !proto.Equal(m, cloneTestMessage) { t.Fatalf("Clone(%v) = %v", cloneTestMessage, m) } // Mutate the clone, which should not affect the original. x1, err := proto.GetExtension(m, pb2.E_Ext_More) if err != nil { t.Errorf("unexpected GetExtension(%v) error: %v", pb2.E_Ext_More.Name, err) } x2, err := proto.GetExtension(m, pb2.E_Ext_Text) if err != nil { t.Errorf("unexpected GetExtension(%v) error: %v", pb2.E_Ext_Text.Name, err) } x3, err := proto.GetExtension(m, pb2.E_Greeting) if err != nil { t.Errorf("unexpected GetExtension(%v) error: %v", pb2.E_Greeting.Name, err) } m.Inner.Port++ (x1.(pb2.Ext)).Data = "blah blah" (x2.(string)) = "goodbye" x3.([]string)[0] = "zero" if !proto.Equal(cloneTestMessage, vanilla) { t.Fatalf("mutation on original detected:\ngot %v\nwant %v", cloneTestMessage, vanilla) } } func TestCloneNil(t testing.T) { var m pb2.MyMessage if c := proto.Clone(m); !proto.Equal(m, c) { t.Errorf("Clone(%v) = %v", m, c) } } var mergeTests = []struct { src, dst, want proto.Message }{ { src: &pb2.MyMessage{ Count: proto.Int32(42), }, dst: &pb2.MyMessage{ Name: proto.String("Dave"), }, want: &pb2.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), }, }, { src: &pb2.MyMessage{ Inner: &pb2.InnerMessage{ Host: proto.String("hey"), Connected: proto.Bool(true), }, Pet: []string{"horsey"}, Others: []pb2.OtherMessage{ { Value: []byte("some bytes"), }, }, }, dst: &pb2.MyMessage{ Inner: &pb2.InnerMessage{ Host: proto.String("niles"), Port: proto.Int32(9099), }, Pet: []string{"bunny", "kitty"}, Others: []pb2.OtherMessage{ { Key: proto.Int64(31415926535), }, { // Explicitly test a src=nil field Inner: nil, }, }, }, want: &pb2.MyMessage{ Inner: &pb2.InnerMessage{ Host: proto.String("hey"), Connected: proto.Bool(true), Port: proto.Int32(9099), }, Pet: []string{"bunny", "kitty", "horsey"}, Others: []pb2.OtherMessage{ { Key: proto.Int64(31415926535), }, {}, { Value: []byte("some bytes"), }, }, }, }, { src: &pb2.MyMessage{ RepBytes: [][]byte{[]byte("wow")}, }, dst: &pb2.MyMessage{ Somegroup: &pb2.MyMessage_SomeGroup{ GroupField: proto.Int32(6), }, RepBytes: [][]byte{[]byte("sham")}, }, want: &pb2.MyMessage{ Somegroup: &pb2.MyMessage_SomeGroup{ GroupField: proto.Int32(6), }, RepBytes: [][]byte{[]byte("sham"), []byte("wow")}, }, }, // Check that a scalar bytes field replaces rather than appends. { src: &pb2.OtherMessage{Value: []byte("foo")}, dst: &pb2.OtherMessage{Value: []byte("bar")}, want: &pb2.OtherMessage{Value: []byte("foo")}, }, { src: &pb2.MessageWithMap{ NameMapping: map[int32]string{6: "Nigel"}, MsgMapping: map[int64]pb2.FloatingPoint{ 0x4001: &pb2.FloatingPoint{F: proto.Float64(2.0)}, 0x4002: &pb2.FloatingPoint{ F: proto.Float64(2.0), }, }, ByteMapping: map[bool][]byte{true: []byte("wowsa")}, }, dst: &pb2.MessageWithMap{ NameMapping: map[int32]string{ 6: "Bruce", // should be overwritten 7: "Andrew", }, MsgMapping: map[int64]pb2.FloatingPoint{ 0x4002: &pb2.FloatingPoint{ F: proto.Float64(3.0), Exact: proto.Bool(true), }, // the entire message should be overwritten }, }, want: &pb2.MessageWithMap{ NameMapping: map[int32]string{ 6: "Nigel", 7: "Andrew", }, MsgMapping: map[int64]pb2.FloatingPoint{ 0x4001: &pb2.FloatingPoint{F: proto.Float64(2.0)}, 0x4002: &pb2.FloatingPoint{ F: proto.Float64(2.0), }, }, ByteMapping: map[bool][]byte{true: []byte("wowsa")}, }, }, // proto3 shouldn't merge zero values, // in the same way that proto2 shouldn't merge nils. { src: &pb3.Message{ Name: "Aaron", Data: []byte(""), // zero value, but not nil }, dst: &pb3.Message{ HeightInCm: 176, Data: []byte("texas!"), }, want: &pb3.Message{ Name: "Aaron", HeightInCm: 176, Data: []byte("texas!"), }, }, { // Oneof fields should merge by assignment. src: &pb2.Communique{Union: &pb2.Communique_Number{41}}, dst: &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}}, want: &pb2.Communique{Union: &pb2.Communique_Number{41}}, }, { // Oneof nil is the same as not set. src: &pb2.Communique{}, dst: &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}}, want: &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}}, }, { src: &pb2.Communique{Union: &pb2.Communique_Number{1337}}, dst: &pb2.Communique{}, want: &pb2.Communique{Union: &pb2.Communique_Number{1337}}, }, { src: &pb2.Communique{Union: &pb2.Communique_Col{pb2.MyMessage_RED}}, dst: &pb2.Communique{}, want: &pb2.Communique{Union: &pb2.Communique_Col{pb2.MyMessage_RED}}, }, { src: &pb2.Communique{Union: &pb2.Communique_Data{[]byte("hello")}}, dst: &pb2.Communique{}, want: &pb2.Communique{Union: &pb2.Communique_Data{[]byte("hello")}}, }, { src: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{BytesField: []byte{1, 2, 3}}}}, dst: &pb2.Communique{}, want: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{BytesField: []byte{1, 2, 3}}}}, }, { src: &pb2.Communique{Union: &pb2.Communique_Msg{}}, dst: &pb2.Communique{}, want: &pb2.Communique{Union: &pb2.Communique_Msg{}}, }, { src: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("123")}}}, dst: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{BytesField: []byte{1, 2, 3}}}}, want: &pb2.Communique{Union: &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("123"), BytesField: []byte{1, 2, 3}}}}, }, { src: &pb3.Message{ Terrain: map[string]pb3.Nested{ "kay_a": &pb3.Nested{Cute: true}, // replace "kay_b": &pb3.Nested{Bunny: "rabbit"}, // insert }, }, dst: &pb3.Message{ Terrain: map[string]pb3.Nested{ "kay_a": &pb3.Nested{Bunny: "lost"}, // replaced "kay_c": &pb3.Nested{Bunny: "bunny"}, // keep }, }, want: &pb3.Message{ Terrain: map[string]pb3.Nested{ "kay_a": &pb3.Nested{Cute: true}, "kay_b": &pb3.Nested{Bunny: "rabbit"}, "kay_c": &pb3.Nested{Bunny: "bunny"}, }, }, }, { src: &pb2.GoTest{ F_BoolRepeated: []bool{}, F_Int32Repeated: []int32{}, F_Int64Repeated: []int64{}, F_Uint32Repeated: []uint32{}, F_Uint64Repeated: []uint64{}, F_FloatRepeated: []float32{}, F_DoubleRepeated: []float64{}, F_StringRepeated: []string{}, F_BytesRepeated: [][]byte{}, }, dst: &pb2.GoTest{}, want: &pb2.GoTest{ F_BoolRepeated: []bool{}, F_Int32Repeated: []int32{}, F_Int64Repeated: []int64{}, F_Uint32Repeated: []uint32{}, F_Uint64Repeated: []uint64{}, F_FloatRepeated: []float32{}, F_DoubleRepeated: []float64{}, F_StringRepeated: []string{}, F_BytesRepeated: [][]byte{}, }, }, { src: &pb2.GoTest{}, dst: &pb2.GoTest{ F_BoolRepeated: []bool{}, F_Int32Repeated: []int32{}, F_Int64Repeated: []int64{}, F_Uint32Repeated: []uint32{}, F_Uint64Repeated: []uint64{}, F_FloatRepeated: []float32{}, F_DoubleRepeated: []float64{}, F_StringRepeated: []string{}, F_BytesRepeated: [][]byte{}, }, want: &pb2.GoTest{ F_BoolRepeated: []bool{}, F_Int32Repeated: []int32{}, F_Int64Repeated: []int64{}, F_Uint32Repeated: []uint32{}, F_Uint64Repeated: []uint64{}, F_FloatRepeated: []float32{}, F_DoubleRepeated: []float64{}, F_StringRepeated: []string{}, F_BytesRepeated: [][]byte{}, }, }, { src: &pb2.GoTest{ F_BytesRepeated: [][]byte{nil, []byte{}, []byte{0}}, }, dst: &pb2.GoTest{}, want: &pb2.GoTest{ F_BytesRepeated: [][]byte{nil, []byte{}, []byte{0}}, }, }, { src: &pb2.MyMessage{ Others: []pb2.OtherMessage{}, }, dst: &pb2.MyMessage{}, want: &pb2.MyMessage{ Others: []pb2.OtherMessage{}, }, }, } func TestMerge(t testing.T) { for _, m := range mergeTests { got := proto.Clone(m.dst) if !proto.Equal(got, m.dst) { t.Errorf("Clone()\ngot %v\nwant %v", got, m.dst) continue } proto.Merge(got, m.src) if !proto.Equal(got, m.want) { t.Errorf("Merge(%v, %v)\ngot %v\nwant %v", m.dst, m.src, got, m.want) } } }	9.94 KB	2025-05-25 12:27
📄 proto_equal_test.go // Copyright 2011 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 ( "testing" "github.com/golang/protobuf/proto" pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto" pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto" ) // Four identical base messages. // The init function adds extensions to some of them. var messageWithoutExtension = &pb2.MyMessage{Count: proto.Int32(7)} var messageWithExtension1a = &pb2.MyMessage{Count: proto.Int32(7)} var messageWithExtension1b = &pb2.MyMessage{Count: proto.Int32(7)} var messageWithExtension2 = &pb2.MyMessage{Count: proto.Int32(7)} var messageWithExtension3a = &pb2.MyMessage{Count: proto.Int32(7)} var messageWithExtension3b = &pb2.MyMessage{Count: proto.Int32(7)} var messageWithExtension3c = &pb2.MyMessage{Count: proto.Int32(7)} // Two messages with non-message extensions. var messageWithInt32Extension1 = &pb2.MyMessage{Count: proto.Int32(8)} var messageWithInt32Extension2 = &pb2.MyMessage{Count: proto.Int32(8)} func init() { ext1 := &pb2.Ext{Data: proto.String("Kirk")} ext2 := &pb2.Ext{Data: proto.String("Picard")} // messageWithExtension1a has ext1, but never marshals it. if err := proto.SetExtension(messageWithExtension1a, pb2.E_Ext_More, ext1); err != nil { panic("proto.SetExtension on 1a failed: " + err.Error()) } // messageWithExtension1b is the unmarshaled form of messageWithExtension1a. if err := proto.SetExtension(messageWithExtension1b, pb2.E_Ext_More, ext1); err != nil { panic("proto.SetExtension on 1b failed: " + err.Error()) } buf, err := proto.Marshal(messageWithExtension1b) if err != nil { panic("proto.Marshal of 1b failed: " + err.Error()) } messageWithExtension1b.Reset() if err := proto.Unmarshal(buf, messageWithExtension1b); err != nil { panic("proto.Unmarshal of 1b failed: " + err.Error()) } // messageWithExtension2 has ext2. if err := proto.SetExtension(messageWithExtension2, pb2.E_Ext_More, ext2); err != nil { panic("proto.SetExtension on 2 failed: " + err.Error()) } if err := proto.SetExtension(messageWithInt32Extension1, pb2.E_Ext_Number, proto.Int32(23)); err != nil { panic("proto.SetExtension on Int32-1 failed: " + err.Error()) } if err := proto.SetExtension(messageWithInt32Extension1, pb2.E_Ext_Number, proto.Int32(24)); err != nil { panic("proto.SetExtension on Int32-2 failed: " + err.Error()) } // messageWithExtension3{a,b,c} has unregistered extension. if proto.RegisteredExtensions(messageWithExtension3a)[200] != nil { panic("expect extension 200 unregistered") } bytes := []byte{ 0xc0, 0x0c, 0x01, // id=200, wiretype=0 (varint), data=1 } bytes2 := []byte{ 0xc0, 0x0c, 0x02, // id=200, wiretype=0 (varint), data=2 } proto.SetRawExtension(messageWithExtension3a, 200, bytes) proto.SetRawExtension(messageWithExtension3b, 200, bytes) proto.SetRawExtension(messageWithExtension3c, 200, bytes2) } var EqualTests = []struct { desc string a, b proto.Message exp bool }{ {"different types", &pb2.GoEnum{}, &pb2.GoTestField{}, false}, {"equal empty", &pb2.GoEnum{}, &pb2.GoEnum{}, true}, {"nil vs nil", nil, nil, true}, {"typed nil vs typed nil", (pb2.GoEnum)(nil), (pb2.GoEnum)(nil), true}, {"typed nil vs empty", (pb2.GoEnum)(nil), &pb2.GoEnum{}, false}, {"different typed nil", (pb2.GoEnum)(nil), (pb2.GoTestField)(nil), false}, {"one set field, one unset field", &pb2.GoTestField{Label: proto.String("foo")}, &pb2.GoTestField{}, false}, {"one set field zero, one unset field", &pb2.GoTest{Param: proto.Int32(0)}, &pb2.GoTest{}, false}, {"different set fields", &pb2.GoTestField{Label: proto.String("foo")}, &pb2.GoTestField{Label: proto.String("bar")}, false}, {"equal set", &pb2.GoTestField{Label: proto.String("foo")}, &pb2.GoTestField{Label: proto.String("foo")}, true}, {"repeated, one set", &pb2.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb2.GoTest{}, false}, {"repeated, different length", &pb2.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb2.GoTest{F_Int32Repeated: []int32{2}}, false}, {"repeated, different value", &pb2.GoTest{F_Int32Repeated: []int32{2}}, &pb2.GoTest{F_Int32Repeated: []int32{3}}, false}, {"repeated, equal", &pb2.GoTest{F_Int32Repeated: []int32{2, 4}}, &pb2.GoTest{F_Int32Repeated: []int32{2, 4}}, true}, {"repeated, nil equal nil", &pb2.GoTest{F_Int32Repeated: nil}, &pb2.GoTest{F_Int32Repeated: nil}, true}, {"repeated, nil equal empty", &pb2.GoTest{F_Int32Repeated: nil}, &pb2.GoTest{F_Int32Repeated: []int32{}}, true}, {"repeated, empty equal nil", &pb2.GoTest{F_Int32Repeated: []int32{}}, &pb2.GoTest{F_Int32Repeated: nil}, true}, { "nested, different", &pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("foo")}}, &pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("bar")}}, false, }, { "nested, equal", &pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("wow")}}, &pb2.GoTest{RequiredField: &pb2.GoTestField{Label: proto.String("wow")}}, true, }, {"bytes", &pb2.OtherMessage{Value: []byte("foo")}, &pb2.OtherMessage{Value: []byte("foo")}, true}, {"bytes, empty", &pb2.OtherMessage{Value: []byte{}}, &pb2.OtherMessage{Value: []byte{}}, true}, {"bytes, empty vs nil", &pb2.OtherMessage{Value: []byte{}}, &pb2.OtherMessage{Value: nil}, false}, { "repeated bytes", &pb2.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}}, &pb2.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}}, true, }, // In proto3, []byte{} and []byte(nil) are equal. {"proto3 bytes, empty vs nil", &pb3.Message{Data: []byte{}}, &pb3.Message{Data: nil}, true}, {"extension vs. no extension", messageWithoutExtension, messageWithExtension1a, false}, {"extension vs. same extension", messageWithExtension1a, messageWithExtension1b, true}, {"extension vs. different extension", messageWithExtension1a, messageWithExtension2, false}, {"int32 extension vs. itself", messageWithInt32Extension1, messageWithInt32Extension1, true}, {"int32 extension vs. a different int32", messageWithInt32Extension1, messageWithInt32Extension2, false}, {"unregistered extension same", messageWithExtension3a, messageWithExtension3b, true}, {"unregistered extension different", messageWithExtension3a, messageWithExtension3c, false}, { "message with group", &pb2.MyMessage{ Count: proto.Int32(1), Somegroup: &pb2.MyMessage_SomeGroup{ GroupField: proto.Int32(5), }, }, &pb2.MyMessage{ Count: proto.Int32(1), Somegroup: &pb2.MyMessage_SomeGroup{ GroupField: proto.Int32(5), }, }, true, }, { "map same", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, true, }, { "map different entry", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, &pb2.MessageWithMap{NameMapping: map[int32]string{2: "Rob"}}, false, }, { "map different key only", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, &pb2.MessageWithMap{NameMapping: map[int32]string{2: "Ken"}}, false, }, { "map different value only", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Rob"}}, false, }, { "zero-length maps same", &pb2.MessageWithMap{NameMapping: map[int32]string{}}, &pb2.MessageWithMap{NameMapping: nil}, true, }, { "orders in map don't matter", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Ken", 2: "Rob"}}, &pb2.MessageWithMap{NameMapping: map[int32]string{2: "Rob", 1: "Ken"}}, true, }, { "oneof same", &pb2.Communique{Union: &pb2.Communique_Number{41}}, &pb2.Communique{Union: &pb2.Communique_Number{41}}, true, }, { "oneof one nil", &pb2.Communique{Union: &pb2.Communique_Number{41}}, &pb2.Communique{}, false, }, { "oneof different", &pb2.Communique{Union: &pb2.Communique_Number{41}}, &pb2.Communique{Union: &pb2.Communique_Name{"Bobby Tables"}}, false, }, } func TestEqual(t testing.T) { for _, tc := range EqualTests { if res := proto.Equal(tc.a, tc.b); res != tc.exp { t.Errorf("%v: Equal(%v, %v) = %v, want %v", tc.desc, tc.a, tc.b, res, tc.exp) } } }	8.08 KB	2025-05-25 12:27
📄 proto_test.go // Copyright 2010 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" "encoding/json" "errors" "fmt" "log" "math" "math/rand" "reflect" "runtime/debug" "strings" "sync" "testing" "time" "github.com/golang/protobuf/proto" "google.golang.org/protobuf/testing/protopack" pb2 "github.com/golang/protobuf/internal/testprotos/proto2_proto" pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto" tspb "github.com/golang/protobuf/ptypes/timestamp" ) func initGoTestField() pb2.GoTestField { f := new(pb2.GoTestField) f.Label = proto.String("label") f.Type = proto.String("type") return f } // These are all structurally equivalent but the tag numbers differ. // (It's remarkable that required, optional, and repeated all have // 8 letters.) func initGoTest_RequiredGroup() pb2.GoTest_RequiredGroup { return &pb2.GoTest_RequiredGroup{ RequiredField: proto.String("required"), } } func initGoTest_OptionalGroup() pb2.GoTest_OptionalGroup { return &pb2.GoTest_OptionalGroup{ RequiredField: proto.String("optional"), } } func initGoTest_RepeatedGroup() pb2.GoTest_RepeatedGroup { return &pb2.GoTest_RepeatedGroup{ RequiredField: proto.String("repeated"), } } func initGoTest(setdefaults bool) pb2.GoTest { pb := new(pb2.GoTest) if setdefaults { pb.F_BoolDefaulted = proto.Bool(pb2.Default_GoTest_F_BoolDefaulted) pb.F_Int32Defaulted = proto.Int32(pb2.Default_GoTest_F_Int32Defaulted) pb.F_Int64Defaulted = proto.Int64(pb2.Default_GoTest_F_Int64Defaulted) pb.F_Fixed32Defaulted = proto.Uint32(pb2.Default_GoTest_F_Fixed32Defaulted) pb.F_Fixed64Defaulted = proto.Uint64(pb2.Default_GoTest_F_Fixed64Defaulted) pb.F_Uint32Defaulted = proto.Uint32(pb2.Default_GoTest_F_Uint32Defaulted) pb.F_Uint64Defaulted = proto.Uint64(pb2.Default_GoTest_F_Uint64Defaulted) pb.F_FloatDefaulted = proto.Float32(pb2.Default_GoTest_F_FloatDefaulted) pb.F_DoubleDefaulted = proto.Float64(pb2.Default_GoTest_F_DoubleDefaulted) pb.F_StringDefaulted = proto.String(pb2.Default_GoTest_F_StringDefaulted) pb.F_BytesDefaulted = pb2.Default_GoTest_F_BytesDefaulted pb.F_Sint32Defaulted = proto.Int32(pb2.Default_GoTest_F_Sint32Defaulted) pb.F_Sint64Defaulted = proto.Int64(pb2.Default_GoTest_F_Sint64Defaulted) pb.F_Sfixed32Defaulted = proto.Int32(pb2.Default_GoTest_F_Sfixed32Defaulted) pb.F_Sfixed64Defaulted = proto.Int64(pb2.Default_GoTest_F_Sfixed64Defaulted) } pb.Kind = pb2.GoTest_TIME.Enum() pb.RequiredField = initGoTestField() pb.F_BoolRequired = proto.Bool(true) pb.F_Int32Required = proto.Int32(3) pb.F_Int64Required = proto.Int64(6) pb.F_Fixed32Required = proto.Uint32(32) pb.F_Fixed64Required = proto.Uint64(64) pb.F_Uint32Required = proto.Uint32(3232) pb.F_Uint64Required = proto.Uint64(6464) pb.F_FloatRequired = proto.Float32(3232) pb.F_DoubleRequired = proto.Float64(6464) pb.F_StringRequired = proto.String("string") pb.F_BytesRequired = []byte("bytes") pb.F_Sint32Required = proto.Int32(-32) pb.F_Sint64Required = proto.Int64(-64) pb.F_Sfixed32Required = proto.Int32(-32) pb.F_Sfixed64Required = proto.Int64(-64) pb.Requiredgroup = initGoTest_RequiredGroup() return pb } func overify(t testing.T, pb pb2.GoTest, want []byte) { bb := new(proto.Buffer) err := bb.Marshal(pb) got := bb.Bytes() if err != nil { t.Logf("overify marshal-1 err = %v", err) } if !bytes.Equal(got, want) { t.Fatalf("got %q\nwant %q", got, want) } // Now test Unmarshal by recreating the original buffer. pbd := new(pb2.GoTest) err = bb.Unmarshal(pbd) if err != nil { t.Fatalf("overify unmarshal err = %v", err) } bb.Reset() err = bb.Marshal(pbd) got = bb.Bytes() if err != nil { t.Fatalf("overify marshal-2 err = %v", err) } if !bytes.Equal(got, want) { t.Fatalf("got %q\nwant %q", got, want) } } // When hooks are enabled, RequiredNotSetError is typed alias to internal/proto // package. Binary serialization has not been wrapped yet and hence produces // requiredNotSetError instead. This function is a work-around to identify both // aliased and non-aliased types. func isRequiredNotSetError(err error) bool { e, ok := err.(interface{ RequiredNotSet() bool }) return ok && e.RequiredNotSet() } // Simple tests for numeric encode/decode primitives (varint, etc.) func TestNumericPrimitives(t testing.T) { for i := uint64(0); i < 1e6; i += 111 { o := new(proto.Buffer) if o.EncodeVarint(i) != nil { t.Error("EncodeVarint") break } x, e := o.DecodeVarint() if e != nil { t.Fatal("DecodeVarint") } if x != i { t.Fatal("varint decode fail:", i, x) } o.Reset() if o.EncodeFixed32(i) != nil { t.Fatal("encFixed32") } x, e = o.DecodeFixed32() if e != nil { t.Fatal("decFixed32") } if x != i { t.Fatal("fixed32 decode fail:", i, x) } o.Reset() if o.EncodeFixed64(i1234567) != nil { t.Error("encFixed64") break } x, e = o.DecodeFixed64() if e != nil { t.Error("decFixed64") break } if x != i1234567 { t.Error("fixed64 decode fail:", i1234567, x) break } o.Reset() i32 := int32(i - 12345) if o.EncodeZigzag32(uint64(i32)) != nil { t.Fatal("EncodeZigzag32") } x, e = o.DecodeZigzag32() if e != nil { t.Fatal("DecodeZigzag32") } if x != uint64(uint32(i32)) { t.Fatal("zigzag32 decode fail:", i32, x) } o.Reset() i64 := int64(i - 12345) if o.EncodeZigzag64(uint64(i64)) != nil { t.Fatal("EncodeZigzag64") } x, e = o.DecodeZigzag64() if e != nil { t.Fatal("DecodeZigzag64") } if x != uint64(i64) { t.Fatal("zigzag64 decode fail:", i64, x) } } } // fakeMarshaler is a simple struct implementing Marshaler and Message interfaces. type fakeMarshaler struct { b []byte err error } func (f fakeMarshaler) Marshal() ([]byte, error) { return f.b, f.err } func (f fakeMarshaler) String() string { return fmt.Sprintf("Bytes: %v Error: %v", f.b, f.err) } func (f fakeMarshaler) ProtoMessage() {} func (f fakeMarshaler) Reset() {} type msgWithFakeMarshaler struct { M fakeMarshaler `protobuf:"bytes,1,opt,name=fake"` } func (m msgWithFakeMarshaler) String() string { return proto.CompactTextString(m) } func (m msgWithFakeMarshaler) ProtoMessage() {} func (m msgWithFakeMarshaler) Reset() {} // Simple tests for proto messages that implement the Marshaler interface. func TestMarshalerEncoding(t testing.T) { tests := []struct { name string m proto.Message want []byte errType reflect.Type }{ { name: "Marshaler that fails", m: &fakeMarshaler{ err: errors.New("some marshal err"), b: []byte{5, 6, 7}, }, errType: reflect.TypeOf(errors.New("some marshal err")), }, { name: "Marshaler that fails with RequiredNotSetError", m: &msgWithFakeMarshaler{ M: &fakeMarshaler{ err: &proto.RequiredNotSetError{}, b: []byte{5, 6, 7}, }, }, errType: reflect.TypeOf(&proto.RequiredNotSetError{}), }, { name: "Marshaler that succeeds", m: &fakeMarshaler{ b: []byte{0, 1, 2, 3, 4, 127, 255}, }, want: []byte{0, 1, 2, 3, 4, 127, 255}, }, } for _, test := range tests { t.Run(test.name, func(t testing.T) { b := proto.NewBuffer(nil) err := b.Marshal(test.m) if reflect.TypeOf(err) != test.errType { t.Errorf("got err %T(%v) wanted %T", err, err, test.errType) } if err != nil { return // skip comparing output when marshal fails. } if !reflect.DeepEqual(test.want, b.Bytes()) { t.Errorf("got bytes %v wanted %v", b.Bytes(), test.want) } if size := proto.Size(test.m); size != len(b.Bytes()) { t.Errorf("Size(_) = %v, but marshaled to %v bytes", size, len(b.Bytes())) } m, mErr := proto.Marshal(test.m) if !bytes.Equal(b.Bytes(), m) { t.Errorf("Marshal returned %v, but (Buffer).Marshal wrote %v", m, b.Bytes()) } if !reflect.DeepEqual(err, mErr) { t.Errorf("Marshal err = %v, but (Buffer).Marshal returned %v", mErr, err) } }) } } // Ensure that Buffer.Marshal uses O(N) memory for N messages func TestBufferMarshalAllocs(t testing.T) { value := &pb2.OtherMessage{Key: proto.Int64(1)} msg := &pb2.MyMessage{Count: proto.Int32(1), Others: []pb2.OtherMessage{value}} for _, prealloc := range []int{0, 100, 10000} { const count = 1000 var b proto.Buffer s := make([]byte, 0, proto.Size(msg)) marshalAllocs := testing.AllocsPerRun(count, func() { b.SetBuf(s) err := b.Marshal(msg) if err != nil { t.Errorf("Marshal err = %q", err) } }) b.SetBuf(make([]byte, 0, prealloc)) bufferAllocs := testing.AllocsPerRun(count, func() { err := b.Marshal(msg) if err != nil { t.Errorf("Marshal err = %q", err) } }) if marshalAllocs != bufferAllocs { t.Errorf("%v allocs/op when writing to a preallocated buffer", marshalAllocs) t.Errorf("%v allocs/op when repeatedly appending to a buffer", bufferAllocs) t.Errorf("expect amortized allocs/op to be identical") } } } // Simple tests for bytes func TestBytesPrimitives(t testing.T) { bb := new(proto.Buffer) want := []byte("now is the time") if err := bb.EncodeRawBytes(want); err != nil { t.Errorf("EncodeRawBytes error: %v", err) } got, err := bb.DecodeRawBytes(false) if err != nil { t.Errorf("DecodeRawBytes error: %v", err) } if !bytes.Equal(got, want) { t.Errorf("got %q\nwant %q", got, want) } } // Simple tests for strings func TestStringPrimitives(t testing.T) { bb := new(proto.Buffer) want := "now is the time" if err := bb.EncodeStringBytes(want); err != nil { t.Errorf("EncodeStringBytes error: %v", err) } got, err := bb.DecodeStringBytes() if err != nil { t.Errorf("DecodeStringBytes error: %v", err) } if got != want { t.Errorf("got %q\nwant %q", got, want) } } // Do we catch the "required bit not set" case? func TestRequiredBit(t testing.T) { o := new(proto.Buffer) pb := new(pb2.GoTest) err := o.Marshal(pb) if err == nil { t.Error("did not catch missing required fields") } else if !strings.Contains(err.Error(), "Kind") { t.Error("wrong error type:", err) } } // Check that all fields are nil. // Clearly silly, and a residue from a more interesting test with an earlier, // different initialization property, but it once caught a compiler bug so // it lives. func checkInitialized(pb pb2.GoTest, t testing.T) { switch { case pb.F_BoolDefaulted != nil: t.Error("New or Reset did not set boolean:", pb.F_BoolDefaulted) case pb.F_Int32Defaulted != nil: t.Error("New or Reset did not set int32:", pb.F_Int32Defaulted) case pb.F_Int64Defaulted != nil: t.Error("New or Reset did not set int64:", pb.F_Int64Defaulted) case pb.F_Fixed32Defaulted != nil: t.Error("New or Reset did not set fixed32:", pb.F_Fixed32Defaulted) case pb.F_Fixed64Defaulted != nil: t.Error("New or Reset did not set fixed64:", pb.F_Fixed64Defaulted) case pb.F_Uint32Defaulted != nil: t.Error("New or Reset did not set uint32:", pb.F_Uint32Defaulted) case pb.F_Uint64Defaulted != nil: t.Error("New or Reset did not set uint64:", pb.F_Uint64Defaulted) case pb.F_FloatDefaulted != nil: t.Error("New or Reset did not set float:", pb.F_FloatDefaulted) case pb.F_DoubleDefaulted != nil: t.Error("New or Reset did not set double:", pb.F_DoubleDefaulted) case pb.F_StringDefaulted != nil: t.Error("New or Reset did not set string:", pb.F_StringDefaulted) case pb.F_BytesDefaulted != nil: t.Error("New or Reset did not set bytes:", string(pb.F_BytesDefaulted)) case pb.F_Sint32Defaulted != nil: t.Error("New or Reset did not set int32:", pb.F_Sint32Defaulted) case pb.F_Sint64Defaulted != nil: t.Error("New or Reset did not set int64:", pb.F_Sint64Defaulted) } } // Does Reset() reset? func TestReset(t testing.T) { pb := initGoTest(true) // muck with some values pb.F_BoolDefaulted = proto.Bool(false) pb.F_Int32Defaulted = proto.Int32(237) pb.F_Int64Defaulted = proto.Int64(12346) pb.F_Fixed32Defaulted = proto.Uint32(32000) pb.F_Fixed64Defaulted = proto.Uint64(666) pb.F_Uint32Defaulted = proto.Uint32(323232) pb.F_Uint64Defaulted = nil pb.F_FloatDefaulted = nil pb.F_DoubleDefaulted = proto.Float64(0) pb.F_StringDefaulted = proto.String("gotcha") pb.F_BytesDefaulted = []byte("asdfasdf") pb.F_Sint32Defaulted = proto.Int32(123) pb.F_Sint64Defaulted = proto.Int64(789) pb.Reset() checkInitialized(pb, t) } // All required fields set, no defaults provided. func TestEncodeDecode1(t testing.T) { pb := initGoTest(false) overify(t, pb, protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{11, protopack.VarintType}, protopack.Varint(3), protopack.Tag{12, protopack.VarintType}, protopack.Varint(6), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), }.Marshal()) } // All required fields set, defaults provided. func TestEncodeDecode2(t testing.T) { pb := initGoTest(true) overify(t, pb, protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{11, protopack.VarintType}, protopack.Varint(3), protopack.Tag{12, protopack.VarintType}, protopack.Varint(6), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{40, protopack.VarintType}, protopack.Bool(true), protopack.Tag{41, protopack.VarintType}, protopack.Varint(32), protopack.Tag{42, protopack.VarintType}, protopack.Varint(64), protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320), protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640), protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200), protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400), protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159), protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828), protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"), protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"), protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64), }.Marshal()) } // All default fields set to their default value by hand func TestEncodeDecode3(t testing.T) { pb := initGoTest(false) pb.F_BoolDefaulted = proto.Bool(true) pb.F_Int32Defaulted = proto.Int32(32) pb.F_Int64Defaulted = proto.Int64(64) pb.F_Fixed32Defaulted = proto.Uint32(320) pb.F_Fixed64Defaulted = proto.Uint64(640) pb.F_Uint32Defaulted = proto.Uint32(3200) pb.F_Uint64Defaulted = proto.Uint64(6400) pb.F_FloatDefaulted = proto.Float32(314159) pb.F_DoubleDefaulted = proto.Float64(271828) pb.F_StringDefaulted = proto.String("hello, \"world!\"\n") pb.F_BytesDefaulted = []byte("Bignose") pb.F_Sint32Defaulted = proto.Int32(-32) pb.F_Sint64Defaulted = proto.Int64(-64) pb.F_Sfixed32Defaulted = proto.Int32(-32) pb.F_Sfixed64Defaulted = proto.Int64(-64) overify(t, pb, protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{11, protopack.VarintType}, protopack.Varint(3), protopack.Tag{12, protopack.VarintType}, protopack.Varint(6), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{40, protopack.VarintType}, protopack.Bool(true), protopack.Tag{41, protopack.VarintType}, protopack.Varint(32), protopack.Tag{42, protopack.VarintType}, protopack.Varint(64), protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320), protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640), protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200), protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400), protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159), protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828), protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"), protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"), protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64), }.Marshal()) } // All required fields set, defaults provided, all non-defaulted optional fields have values. func TestEncodeDecode4(t testing.T) { pb := initGoTest(true) pb.Table = proto.String("hello") pb.Param = proto.Int32(7) pb.OptionalField = initGoTestField() pb.F_BoolOptional = proto.Bool(true) pb.F_Int32Optional = proto.Int32(32) pb.F_Int64Optional = proto.Int64(64) pb.F_Fixed32Optional = proto.Uint32(3232) pb.F_Fixed64Optional = proto.Uint64(6464) pb.F_Uint32Optional = proto.Uint32(323232) pb.F_Uint64Optional = proto.Uint64(646464) pb.F_FloatOptional = proto.Float32(32.) pb.F_DoubleOptional = proto.Float64(64.) pb.F_StringOptional = proto.String("hello") pb.F_BytesOptional = []byte("Bignose") pb.F_Sint32Optional = proto.Int32(-32) pb.F_Sint64Optional = proto.Int64(-64) pb.F_Sfixed32Optional = proto.Int32(-32) pb.F_Sfixed64Optional = proto.Int64(-64) pb.Optionalgroup = initGoTest_OptionalGroup() overify(t, pb, protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{2, protopack.BytesType}, protopack.String("hello"), protopack.Tag{3, protopack.VarintType}, protopack.Varint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{6, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{11, protopack.VarintType}, protopack.Varint(3), protopack.Tag{12, protopack.VarintType}, protopack.Varint(6), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{30, protopack.VarintType}, protopack.Bool(true), protopack.Tag{31, protopack.VarintType}, protopack.Varint(32), protopack.Tag{32, protopack.VarintType}, protopack.Varint(64), protopack.Tag{33, protopack.Fixed32Type}, protopack.Uint32(3232), protopack.Tag{34, protopack.Fixed64Type}, protopack.Uint64(6464), protopack.Tag{35, protopack.VarintType}, protopack.Uvarint(323232), protopack.Tag{36, protopack.VarintType}, protopack.Uvarint(646464), protopack.Tag{37, protopack.Fixed32Type}, protopack.Float32(32), protopack.Tag{38, protopack.Fixed64Type}, protopack.Float64(64), protopack.Tag{39, protopack.BytesType}, protopack.String("hello"), protopack.Tag{40, protopack.VarintType}, protopack.Bool(true), protopack.Tag{41, protopack.VarintType}, protopack.Varint(32), protopack.Tag{42, protopack.VarintType}, protopack.Varint(64), protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320), protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640), protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200), protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400), protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159), protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828), protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"), protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{90, protopack.StartGroupType}, protopack.Message{ protopack.Tag{91, protopack.BytesType}, protopack.String("optional"), }, protopack.Tag{90, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{301, protopack.BytesType}, protopack.Bytes("Bignose"), protopack.Tag{302, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{303, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{304, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{305, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"), protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64), }.Marshal()) } // All required fields set, defaults provided, all repeated fields given two values. func TestEncodeDecode5(t testing.T) { pb := initGoTest(true) pb.RepeatedField = []pb2.GoTestField{initGoTestField(), initGoTestField()} pb.F_BoolRepeated = []bool{false, true} pb.F_Int32Repeated = []int32{32, 33} pb.F_Int64Repeated = []int64{64, 65} pb.F_Fixed32Repeated = []uint32{3232, 3333} pb.F_Fixed64Repeated = []uint64{6464, 6565} pb.F_Uint32Repeated = []uint32{323232, 333333} pb.F_Uint64Repeated = []uint64{646464, 656565} pb.F_FloatRepeated = []float32{32., 33.} pb.F_DoubleRepeated = []float64{64., 65.} pb.F_StringRepeated = []string{"hello", "sailor"} pb.F_BytesRepeated = [][]byte{[]byte("big"), []byte("nose")} pb.F_Sint32Repeated = []int32{32, -32} pb.F_Sint64Repeated = []int64{64, -64} pb.F_Sfixed32Repeated = []int32{32, -32} pb.F_Sfixed64Repeated = []int64{64, -64} pb.Repeatedgroup = []pb2.GoTest_RepeatedGroup{initGoTest_RepeatedGroup(), initGoTest_RepeatedGroup()} overify(t, pb, protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{5, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{5, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{11, protopack.VarintType}, protopack.Varint(3), protopack.Tag{12, protopack.VarintType}, protopack.Varint(6), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{20, protopack.VarintType}, protopack.Bool(false), protopack.Tag{20, protopack.VarintType}, protopack.Bool(true), protopack.Tag{21, protopack.VarintType}, protopack.Varint(32), protopack.Tag{21, protopack.VarintType}, protopack.Varint(33), protopack.Tag{22, protopack.VarintType}, protopack.Varint(64), protopack.Tag{22, protopack.VarintType}, protopack.Varint(65), protopack.Tag{23, protopack.Fixed32Type}, protopack.Uint32(3232), protopack.Tag{23, protopack.Fixed32Type}, protopack.Uint32(3333), protopack.Tag{24, protopack.Fixed64Type}, protopack.Uint64(6464), protopack.Tag{24, protopack.Fixed64Type}, protopack.Uint64(6565), protopack.Tag{25, protopack.VarintType}, protopack.Uvarint(323232), protopack.Tag{25, protopack.VarintType}, protopack.Uvarint(333333), protopack.Tag{26, protopack.VarintType}, protopack.Uvarint(646464), protopack.Tag{26, protopack.VarintType}, protopack.Uvarint(656565), protopack.Tag{27, protopack.Fixed32Type}, protopack.Float32(32), protopack.Tag{27, protopack.Fixed32Type}, protopack.Float32(33), protopack.Tag{28, protopack.Fixed64Type}, protopack.Float64(64), protopack.Tag{28, protopack.Fixed64Type}, protopack.Float64(65), protopack.Tag{29, protopack.BytesType}, protopack.String("hello"), protopack.Tag{29, protopack.BytesType}, protopack.String("sailor"), protopack.Tag{40, protopack.VarintType}, protopack.Bool(true), protopack.Tag{41, protopack.VarintType}, protopack.Varint(32), protopack.Tag{42, protopack.VarintType}, protopack.Varint(64), protopack.Tag{43, protopack.Fixed32Type}, protopack.Uint32(320), protopack.Tag{44, protopack.Fixed64Type}, protopack.Uint64(640), protopack.Tag{45, protopack.VarintType}, protopack.Uvarint(3200), protopack.Tag{46, protopack.VarintType}, protopack.Uvarint(6400), protopack.Tag{47, protopack.Fixed32Type}, protopack.Float32(314159), protopack.Tag{48, protopack.Fixed64Type}, protopack.Float64(271828), protopack.Tag{49, protopack.BytesType}, protopack.String("hello, \"world!\"\n"), protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{80, protopack.StartGroupType}, protopack.Message{ protopack.Tag{81, protopack.BytesType}, protopack.String("repeated"), }, protopack.Tag{80, protopack.EndGroupType}, protopack.Tag{80, protopack.StartGroupType}, protopack.Message{ protopack.Tag{81, protopack.BytesType}, protopack.String("repeated"), }, protopack.Tag{80, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{201, protopack.BytesType}, protopack.Bytes("big"), protopack.Tag{201, protopack.BytesType}, protopack.Bytes("nose"), protopack.Tag{202, protopack.VarintType}, protopack.Svarint(32), protopack.Tag{202, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{203, protopack.VarintType}, protopack.Svarint(64), protopack.Tag{203, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{204, protopack.Fixed32Type}, protopack.Int32(32), protopack.Tag{204, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{205, protopack.Fixed64Type}, protopack.Int64(64), protopack.Tag{205, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{401, protopack.BytesType}, protopack.Bytes("Bignose"), protopack.Tag{402, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{403, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{404, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{405, protopack.Fixed64Type}, protopack.Int64(-64), }.Marshal()) } // All required fields set, all packed repeated fields given two values. func TestEncodeDecode6(t testing.T) { pb := initGoTest(false) pb.F_BoolRepeatedPacked = []bool{false, true} pb.F_Int32RepeatedPacked = []int32{32, 33} pb.F_Int64RepeatedPacked = []int64{64, 65} pb.F_Fixed32RepeatedPacked = []uint32{3232, 3333} pb.F_Fixed64RepeatedPacked = []uint64{6464, 6565} pb.F_Uint32RepeatedPacked = []uint32{323232, 333333} pb.F_Uint64RepeatedPacked = []uint64{646464, 656565} pb.F_FloatRepeatedPacked = []float32{32., 33.} pb.F_DoubleRepeatedPacked = []float64{64., 65.} pb.F_Sint32RepeatedPacked = []int32{32, -32} pb.F_Sint64RepeatedPacked = []int64{64, -64} pb.F_Sfixed32RepeatedPacked = []int32{32, -32} pb.F_Sfixed64RepeatedPacked = []int64{64, -64} overify(t, pb, protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("label"), protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{11, protopack.VarintType}, protopack.Varint(3), protopack.Tag{12, protopack.VarintType}, protopack.Varint(6), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{50, protopack.BytesType}, protopack.LengthPrefix{protopack.Bool(false), protopack.Bool(true)}, protopack.Tag{51, protopack.BytesType}, protopack.LengthPrefix{protopack.Varint(32), protopack.Varint(33)}, protopack.Tag{52, protopack.BytesType}, protopack.LengthPrefix{protopack.Varint(64), protopack.Varint(65)}, protopack.Tag{53, protopack.BytesType}, protopack.LengthPrefix{protopack.Uint32(3232), protopack.Uint32(3333)}, protopack.Tag{54, protopack.BytesType}, protopack.LengthPrefix{protopack.Uint64(6464), protopack.Uint64(6565)}, protopack.Tag{55, protopack.BytesType}, protopack.LengthPrefix{protopack.Uvarint(323232), protopack.Uvarint(333333)}, protopack.Tag{56, protopack.BytesType}, protopack.LengthPrefix{protopack.Uvarint(646464), protopack.Uvarint(656565)}, protopack.Tag{57, protopack.BytesType}, protopack.LengthPrefix{protopack.Float32(32), protopack.Float32(33)}, protopack.Tag{58, protopack.BytesType}, protopack.LengthPrefix{protopack.Float64(64), protopack.Float64(65)}, protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), protopack.Tag{502, protopack.BytesType}, protopack.LengthPrefix{protopack.Svarint(32), protopack.Svarint(-32)}, protopack.Tag{503, protopack.BytesType}, protopack.LengthPrefix{protopack.Svarint(64), protopack.Svarint(-64)}, protopack.Tag{504, protopack.BytesType}, protopack.LengthPrefix{protopack.Int32(32), protopack.Int32(-32)}, protopack.Tag{505, protopack.BytesType}, protopack.LengthPrefix{protopack.Int64(64), protopack.Int64(-64)}, }.Marshal()) } // Test that we can encode empty bytes fields. func TestEncodeDecodeBytes1(t testing.T) { pb := initGoTest(false) // Create our bytes pb.F_BytesRequired = []byte{} pb.F_BytesRepeated = [][]byte{{}} pb.F_BytesOptional = []byte{} d, err := proto.Marshal(pb) if err != nil { t.Error(err) } pbd := new(pb2.GoTest) if err := proto.Unmarshal(d, pbd); err != nil { t.Error(err) } if pbd.F_BytesRequired == nil \|\| len(pbd.F_BytesRequired) != 0 { t.Error("required empty bytes field is incorrect") } if pbd.F_BytesRepeated == nil \|\| len(pbd.F_BytesRepeated) == 1 && pbd.F_BytesRepeated[0] == nil { t.Error("repeated empty bytes field is incorrect") } if pbd.F_BytesOptional == nil \|\| len(pbd.F_BytesOptional) != 0 { t.Error("optional empty bytes field is incorrect") } } // Test that we encode nil-valued fields of a repeated bytes field correctly. // Since entries in a repeated field cannot be nil, nil must mean empty value. func TestEncodeDecodeBytes2(t testing.T) { pb := initGoTest(false) // Create our bytes pb.F_BytesRepeated = [][]byte{nil} d, err := proto.Marshal(pb) if err != nil { t.Error(err) } pbd := new(pb2.GoTest) if err := proto.Unmarshal(d, pbd); err != nil { t.Error(err) } if len(pbd.F_BytesRepeated) != 1 \|\| pbd.F_BytesRepeated[0] == nil { t.Error("Unexpected value for repeated bytes field") } } // All required fields set, defaults provided, all repeated fields given two values. func TestSkippingUnrecognizedFields(t testing.T) { o := new(proto.Buffer) pb := initGoTestField() // Marshal it normally. o.Marshal(pb) // Now new a GoSkipTest record. skip := &pb2.GoSkipTest{ SkipInt32: proto.Int32(32), SkipFixed32: proto.Uint32(3232), SkipFixed64: proto.Uint64(6464), SkipString: proto.String("skipper"), Skipgroup: &pb2.GoSkipTest_SkipGroup{ GroupInt32: proto.Int32(75), GroupString: proto.String("wxyz"), }, } // Marshal it into same buffer. o.Marshal(skip) pbd := new(pb2.GoTestField) o.Unmarshal(pbd) // The __unrecognized field should be a marshaling of GoSkipTest skipd := new(pb2.GoSkipTest) o.SetBuf(pbd.XXX_unrecognized) o.Unmarshal(skipd) switch { case skipd.SkipInt32 != skip.SkipInt32: t.Error("skip int32", skipd.SkipInt32) case skipd.SkipFixed32 != skip.SkipFixed32: t.Error("skip fixed32", skipd.SkipFixed32) case skipd.SkipFixed64 != skip.SkipFixed64: t.Error("skip fixed64", skipd.SkipFixed64) case skipd.SkipString != skip.SkipString: t.Error("skip string", skipd.SkipString) case skipd.Skipgroup.GroupInt32 != skip.Skipgroup.GroupInt32: t.Error("skip group int32", skipd.Skipgroup.GroupInt32) case skipd.Skipgroup.GroupString != skip.Skipgroup.GroupString: t.Error("skip group string", skipd.Skipgroup.GroupString) } } // Check that unrecognized fields of a submessage are preserved. func TestSubmessageUnrecognizedFields(t testing.T) { nm := &pb2.NewMessage{ Nested: &pb2.NewMessage_Nested{ Name: proto.String("Nigel"), FoodGroup: proto.String("carbs"), }, } b, err := proto.Marshal(nm) if err != nil { t.Fatalf("Marshal of NewMessage: %v", err) } // Unmarshal into an OldMessage. om := new(pb2.OldMessage) if err := proto.Unmarshal(b, om); err != nil { t.Fatalf("Unmarshal to OldMessage: %v", err) } exp := &pb2.OldMessage{ Nested: &pb2.OldMessage_Nested{ Name: proto.String("Nigel"), // normal protocol buffer users should not do this XXX_unrecognized: []byte("\x12\x05carbs"), }, } if !proto.Equal(om, exp) { t.Errorf("om = %v, want %v", om, exp) } // Clone the OldMessage. om = proto.Clone(om).(pb2.OldMessage) if !proto.Equal(om, exp) { t.Errorf("Clone(om) = %v, want %v", om, exp) } // Marshal the OldMessage, then unmarshal it into an empty NewMessage. if b, err = proto.Marshal(om); err != nil { t.Fatalf("Marshal of OldMessage: %v", err) } t.Logf("Marshal(%v) -> %q", om, b) nm2 := new(pb2.NewMessage) if err := proto.Unmarshal(b, nm2); err != nil { t.Fatalf("Unmarshal to NewMessage: %v", err) } if !proto.Equal(nm, nm2) { t.Errorf("NewMessage round-trip: %v => %v", nm, nm2) } } // Check that an int32 field can be upgraded to an int64 field. func TestNegativeInt32(t testing.T) { om := &pb2.OldMessage{ Num: proto.Int32(-1), } b, err := proto.Marshal(om) if err != nil { t.Fatalf("Marshal of OldMessage: %v", err) } // Check the size. It should be 11 bytes; // 1 for the field/wire type, and 10 for the negative number. if len(b) != 11 { t.Errorf("%v marshaled as %q, wanted 11 bytes", om, b) } // Unmarshal into a NewMessage. nm := new(pb2.NewMessage) if err := proto.Unmarshal(b, nm); err != nil { t.Fatalf("Unmarshal to NewMessage: %v", err) } want := &pb2.NewMessage{ Num: proto.Int64(-1), } if !proto.Equal(nm, want) { t.Errorf("nm = %v, want %v", nm, want) } } // Check that we can grow an array (repeated field) to have many elements. // This test doesn't depend only on our encoding; for variety, it makes sure // we create, encode, and decode the correct contents explicitly. It's therefore // a bit messier. // This test also uses (and hence tests) the Marshal/Unmarshal functions // instead of the methods. func TestBigRepeated(t testing.T) { pb := initGoTest(true) // Create the arrays const N = 50 // Internally the library starts much smaller. pb.Repeatedgroup = make([]pb2.GoTest_RepeatedGroup, N) pb.F_Sint64Repeated = make([]int64, N) pb.F_Sint32Repeated = make([]int32, N) pb.F_BytesRepeated = make([][]byte, N) pb.F_StringRepeated = make([]string, N) pb.F_DoubleRepeated = make([]float64, N) pb.F_FloatRepeated = make([]float32, N) pb.F_Uint64Repeated = make([]uint64, N) pb.F_Uint32Repeated = make([]uint32, N) pb.F_Fixed64Repeated = make([]uint64, N) pb.F_Fixed32Repeated = make([]uint32, N) pb.F_Int64Repeated = make([]int64, N) pb.F_Int32Repeated = make([]int32, N) pb.F_BoolRepeated = make([]bool, N) pb.RepeatedField = make([]pb2.GoTestField, N) // Fill in the arrays with checkable values. igtf := initGoTestField() igtrg := initGoTest_RepeatedGroup() for i := 0; i < N; i++ { pb.Repeatedgroup[i] = igtrg pb.F_Sint64Repeated[i] = int64(i) pb.F_Sint32Repeated[i] = int32(i) s := fmt.Sprint(i) pb.F_BytesRepeated[i] = []byte(s) pb.F_StringRepeated[i] = s pb.F_DoubleRepeated[i] = float64(i) pb.F_FloatRepeated[i] = float32(i) pb.F_Uint64Repeated[i] = uint64(i) pb.F_Uint32Repeated[i] = uint32(i) pb.F_Fixed64Repeated[i] = uint64(i) pb.F_Fixed32Repeated[i] = uint32(i) pb.F_Int64Repeated[i] = int64(i) pb.F_Int32Repeated[i] = int32(i) pb.F_BoolRepeated[i] = i%2 == 0 pb.RepeatedField[i] = igtf } // Marshal. buf, _ := proto.Marshal(pb) // Now test Unmarshal by recreating the original buffer. pbd := new(pb2.GoTest) proto.Unmarshal(buf, pbd) // Check the checkable values for i := uint64(0); i < N; i++ { switch { case pbd.Repeatedgroup[i] == nil: t.Error("pbd.Repeatedgroup bad") case uint64(pbd.F_Sint64Repeated[i]) != i: t.Error("pbd.F_Sint64Repeated bad", uint64(pbd.F_Sint64Repeated[i]), i) case uint64(pbd.F_Sint32Repeated[i]) != i: t.Error("pbd.F_Sint32Repeated bad", uint64(pbd.F_Sint32Repeated[i]), i) case !bytes.Equal(pbd.F_BytesRepeated[i], []byte(fmt.Sprint(i))): t.Error("pbd.F_BytesRepeated bad", pbd.F_BytesRepeated[i], i) case pbd.F_StringRepeated[i] != string(fmt.Sprint(i)): t.Error("pbd.F_Sint32Repeated bad", pbd.F_StringRepeated[i], i) case uint64(pbd.F_DoubleRepeated[i]) != i: t.Error("pbd.F_DoubleRepeated bad", uint64(pbd.F_DoubleRepeated[i]), i) case uint64(pbd.F_FloatRepeated[i]) != i: t.Error("pbd.F_FloatRepeated bad", uint64(pbd.F_FloatRepeated[i]), i) case pbd.F_Uint64Repeated[i] != i: t.Error("pbd.F_Uint64Repeated bad", pbd.F_Uint64Repeated[i], i) case uint64(pbd.F_Uint32Repeated[i]) != i: t.Error("pbd.F_Uint32Repeated bad", uint64(pbd.F_Uint32Repeated[i]), i) case pbd.F_Fixed64Repeated[i] != i: t.Error("pbd.F_Fixed64Repeated bad", pbd.F_Fixed64Repeated[i], i) case uint64(pbd.F_Fixed32Repeated[i]) != i: t.Error("pbd.F_Fixed32Repeated bad", uint64(pbd.F_Fixed32Repeated[i]), i) case uint64(pbd.F_Int64Repeated[i]) != i: t.Error("pbd.F_Int64Repeated bad", uint64(pbd.F_Int64Repeated[i]), i) case uint64(pbd.F_Int32Repeated[i]) != i: t.Error("pbd.F_Int32Repeated bad", uint64(pbd.F_Int32Repeated[i]), i) case pbd.F_BoolRepeated[i] != (i%2 == 0): t.Error("pbd.F_BoolRepeated bad", pbd.F_BoolRepeated[i], i) case pbd.RepeatedField[i] == nil: t.Error("pbd.RepeatedField bad") } } } func TestBadWireTypeUnknown(t testing.T) { b := protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.Bytes("x"), protopack.Tag{1, protopack.Fixed32Type}, protopack.Uint32(0), protopack.Tag{1, protopack.VarintType}, protopack.Varint(11), protopack.Tag{2, protopack.VarintType}, protopack.Uvarint(22), protopack.Tag{2, protopack.BytesType}, protopack.String("aaa"), protopack.Tag{2, protopack.Fixed32Type}, protopack.Uint32(33), protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(44), protopack.Tag{4, protopack.BytesType}, protopack.String("bbb"), protopack.Tag{4, protopack.Fixed32Type}, protopack.Uint32(55), protopack.Tag{4, protopack.BytesType}, protopack.String("ccc"), protopack.Tag{4, protopack.Fixed64Type}, protopack.Uint64(66), protopack.Tag{11, protopack.VarintType}, protopack.Uvarint(77), protopack.Tag{11, protopack.BytesType}, protopack.Bytes("ddd"), protopack.Tag{11, protopack.Fixed64Type}, protopack.Float64(88), protopack.Tag{11, protopack.Fixed32Type}, protopack.Uint32(99), }.Marshal() m := new(pb2.MyMessage) if err := proto.Unmarshal(b, m); err != nil { t.Errorf("unexpected Unmarshal error: %v", err) } unknown := protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.Bytes("x"), protopack.Tag{1, protopack.Fixed32Type}, protopack.Uint32(0), protopack.Tag{2, protopack.VarintType}, protopack.Uvarint(22), protopack.Tag{2, protopack.Fixed32Type}, protopack.Uint32(33), protopack.Tag{4, protopack.VarintType}, protopack.Uvarint(44), protopack.Tag{4, protopack.Fixed32Type}, protopack.Uint32(55), protopack.Tag{4, protopack.Fixed64Type}, protopack.Uint64(66), protopack.Tag{11, protopack.VarintType}, protopack.Uvarint(77), protopack.Tag{11, protopack.BytesType}, protopack.Bytes("ddd"), protopack.Tag{11, protopack.Fixed32Type}, protopack.Uint32(99), }.Marshal() if !bytes.Equal(m.XXX_unrecognized, unknown) { t.Errorf("unknown bytes mismatch:\ngot %x\nwant %x", m.XXX_unrecognized, unknown) } proto.DiscardUnknown(m) want := &pb2.MyMessage{Count: proto.Int32(11), Name: proto.String("aaa"), Pet: []string{"bbb", "ccc"}, Bigfloat: proto.Float64(88)} if !proto.Equal(m, want) { t.Errorf("message mismatch:\ngot %v\nwant %v", m, want) } } func encodeDecode(t testing.T, in, out proto.Message, msg string) { buf, err := proto.Marshal(in) if err != nil { t.Fatalf("failed marshaling %v: %v", msg, err) } if err := proto.Unmarshal(buf, out); err != nil { t.Fatalf("failed unmarshaling %v: %v", msg, err) } } func TestPackedNonPackedDecoderSwitching(t testing.T) { np, p := new(pb2.NonPackedTest), new(pb2.PackedTest) // non-packed -> packed np.A = []int32{0, 1, 1, 2, 3, 5} encodeDecode(t, np, p, "non-packed -> packed") if !reflect.DeepEqual(np.A, p.B) { t.Errorf("failed non-packed -> packed; np.A=%+v, p.B=%+v", np.A, p.B) } // packed -> non-packed np.Reset() p.B = []int32{3, 1, 4, 1, 5, 9} encodeDecode(t, p, np, "packed -> non-packed") if !reflect.DeepEqual(p.B, np.A) { t.Errorf("failed packed -> non-packed; p.B=%+v, np.A=%+v", p.B, np.A) } } func TestProto1RepeatedGroup(t testing.T) { pb := &pb2.MessageList{ Message: []pb2.MessageList_Message{ { Name: proto.String("blah"), Count: proto.Int32(7), }, // NOTE: pb.Message[1] is a nil nil, }, } o := new(proto.Buffer) err := o.Marshal(pb) if err == nil { t.Fatalf("expected error when marshaling repeted nil MessageList.Message") } if _, ok := err.(proto.RequiredNotSetError); !ok { t.Fatalf("unexpected error when marshaling: %v", err) } } // Test that enums work. Checks for a bug introduced by making enums // named types instead of int32: newInt32FromUint64 would crash with // a type mismatch in reflect.PointTo. func TestEnum(t testing.T) { pb := new(pb2.GoEnum) pb.Foo = pb2.FOO_FOO1.Enum() o := new(proto.Buffer) if err := o.Marshal(pb); err != nil { t.Fatal("error encoding enum:", err) } pb1 := new(pb2.GoEnum) if err := o.Unmarshal(pb1); err != nil { t.Fatal("error decoding enum:", err) } if pb1.Foo != pb2.FOO_FOO1 { t.Error("expected 7 but got ", pb1.Foo) } } // Enum types have String methods. Check that enum fields can be printed. // We don't care what the value actually is, just as long as it doesn't crash. func TestPrintingNilEnumFields(t testing.T) { pb := new(pb2.GoEnum) _ = fmt.Sprintf("%+v", pb) } // Verify that absent required fields cause Marshal/Unmarshal to return errors. func TestRequiredFieldEnforcement(t testing.T) { pb := new(pb2.GoTestField) _, err := proto.Marshal(pb) if err == nil { t.Error("marshal: expected error, got nil") } else if !isRequiredNotSetError(err) { t.Errorf("marshal: bad error type: %v", err) } // A slightly sneaky, yet valid, proto. It encodes the same required field twice, // so simply counting the required fields is insufficient. // field 1, encoding 2, value "hi" buf := []byte("\x0A\x02hi\x0A\x02hi") err = proto.Unmarshal(buf, pb) if err == nil { t.Error("unmarshal: expected error, got nil") } else if !isRequiredNotSetError(err) { t.Errorf("unmarshal: bad error type: %v", err) } } // Verify that absent required fields in groups cause Marshal/Unmarshal to return errors. func TestRequiredFieldEnforcementGroups(t testing.T) { pb := &pb2.GoTestRequiredGroupField{Group: &pb2.GoTestRequiredGroupField_Group{}} if _, err := proto.Marshal(pb); err == nil { t.Error("marshal: expected error, got nil") } else if !isRequiredNotSetError(err) { t.Errorf("marshal: bad error type: %v", err) } buf := []byte{11, 12} if err := proto.Unmarshal(buf, pb); err == nil { t.Error("unmarshal: expected error, got nil") } else if !isRequiredNotSetError(err) { t.Errorf("unmarshal: bad error type: %v", err) } } func TestTypedNilMarshal(t testing.T) { // A typed nil should return ErrNil and not crash. var m pb2.GoEnum if _, err := proto.Marshal(m); err != proto.ErrNil { t.Errorf("Marshal(%#v): got %v, want ErrNil", m, err) } } func TestTypedNilMarshalInOneof(t testing.T) { // It should not panic. m := &pb2.Communique{Union: &pb2.Communique_Msg{nil}} if _, err := proto.Marshal(m); err == proto.ErrNil { t.Errorf("Marshal(%#v): got %v, want nil or errOneofHasNil", m, err) } } // A type that implements the Marshaler interface, but is not nillable. type nonNillableInt uint64 func (nni nonNillableInt) Marshal() ([]byte, error) { return proto.EncodeVarint(uint64(nni)), nil } type NNIMessage struct { nni nonNillableInt } func (NNIMessage) Reset() {} func (NNIMessage) String() string { return "" } func (NNIMessage) ProtoMessage() {} type NMMessage struct{} func (NMMessage) Reset() {} func (NMMessage) String() string { return "" } func (NMMessage) ProtoMessage() {} // Verify a type that uses the Marshaler interface, but has a nil pointer. func TestNilMarshaler(t testing.T) { // Try a struct with a Marshaler field that is nil. // It should be directly marshable. nmm := new(NMMessage) if _, err := proto.Marshal(nmm); err != nil { t.Error("unexpected error marshaling nmm: ", err) } // Try a struct with a Marshaler field that is not nillable. nnim := new(NNIMessage) nnim.nni = 7 var _ proto.Marshaler = nnim.nni // verify it is truly a Marshaler if _, err := proto.Marshal(nnim); err != nil { t.Error("unexpected error marshaling nnim: ", err) } } func TestAllSetDefaults(t testing.T) { // Exercise SetDefaults with all scalar field types. got := &pb2.Defaults{ // NaN != NaN, so override that here. F_Nan: proto.Float32(1.7), } want := &pb2.Defaults{ F_Bool: proto.Bool(true), F_Int32: proto.Int32(32), F_Int64: proto.Int64(64), F_Fixed32: proto.Uint32(320), F_Fixed64: proto.Uint64(640), F_Uint32: proto.Uint32(3200), F_Uint64: proto.Uint64(6400), F_Float: proto.Float32(314159), F_Double: proto.Float64(271828), F_String: proto.String(`hello, "world!"` + "\n"), F_Bytes: []byte("Bignose"), F_Sint32: proto.Int32(-32), F_Sint64: proto.Int64(-64), F_Enum: pb2.Defaults_GREEN.Enum(), F_Pinf: proto.Float32(float32(math.Inf(1))), F_Ninf: proto.Float32(float32(math.Inf(-1))), F_Nan: proto.Float32(1.7), StrZero: proto.String(""), } proto.SetDefaults(got) if !proto.Equal(got, want) { t.Errorf("SetDefaults failed\n got %v\nwant %v", got, want) } } func TestSetDefaultsWithSetField(t testing.T) { // Check that a set value is not overridden. m := &pb2.Defaults{ F_Int32: proto.Int32(12), } proto.SetDefaults(m) if v := m.GetF_Int32(); v != 12 { t.Errorf("m.FInt32 = %v, want 12", v) } } func TestSetDefaultsWithSubMessage(t testing.T) { got := &pb2.OtherMessage{ Key: proto.Int64(123), Inner: &pb2.InnerMessage{ Host: proto.String("gopher"), }, } want := &pb2.OtherMessage{ Key: proto.Int64(123), Inner: &pb2.InnerMessage{ Host: proto.String("gopher"), Port: proto.Int32(4000), }, } proto.SetDefaults(got) if !proto.Equal(got, want) { t.Errorf("\n got %v\nwant %v", got, want) } } func TestSetDefaultsWithRepeatedSubMessage(t testing.T) { got := &pb2.MyMessage{ RepInner: []pb2.InnerMessage{{}}, } want := &pb2.MyMessage{ RepInner: []pb2.InnerMessage{{ Port: proto.Int32(4000), }}, } proto.SetDefaults(got) if !proto.Equal(got, want) { t.Errorf("\n got %v\nwant %v", got, want) } } func TestSetDefaultWithRepeatedNonMessage(t testing.T) { got := &pb2.MyMessage{ Pet: []string{"turtle", "wombat"}, } want := proto.Clone(got) proto.SetDefaults(got) if !proto.Equal(got, want) { t.Errorf("\n got %v\nwant %v", got, want) } } func TestMaximumTagNumber(t testing.T) { m := &pb2.MaxTag{ LastField: proto.String("natural goat essence"), } buf, err := proto.Marshal(m) if err != nil { t.Fatalf("proto.Marshal failed: %v", err) } m2 := new(pb2.MaxTag) if err := proto.Unmarshal(buf, m2); err != nil { t.Fatalf("proto.Unmarshal failed: %v", err) } if got, want := m2.GetLastField(), m.LastField; got != want { t.Errorf("got %q, want %q", got, want) } } func TestJSON(t testing.T) { m := &pb2.MyMessage{ Count: proto.Int32(4), Pet: []string{"bunny", "kitty"}, Inner: &pb2.InnerMessage{ Host: proto.String("cauchy"), }, Bikeshed: pb2.MyMessage_GREEN.Enum(), } const want = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":1}` b, err := json.Marshal(m) if err != nil { t.Fatalf("json.Marshal failed: %v", err) } s := string(b) if s != want { t.Errorf("got %s\nwant %s", s, want) } received := new(pb2.MyMessage) if err := json.Unmarshal(b, received); err != nil { t.Fatalf("json.Unmarshal failed: %v", err) } if !proto.Equal(received, m) { t.Fatalf("got %s, want %s", received, m) } // Test unmarshaling of JSON with symbolic enum name. const old = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":"GREEN"}` received.Reset() if err := json.Unmarshal([]byte(old), received); err != nil { t.Fatalf("json.Unmarshal failed: %v", err) } if !proto.Equal(received, m) { t.Fatalf("got %s, want %s", received, m) } } func TestBadWireType(t testing.T) { b := []byte{7<<3 \| 6} // field 7, wire type 6 pb := new(pb2.OtherMessage) if err := proto.Unmarshal(b, pb); err == nil { t.Errorf("Unmarshal did not fail") } } func TestBytesWithInvalidLength(t testing.T) { // If a byte sequence has an invalid (negative) length, Unmarshal should not panic. b := protopack.Message{ protopack.Tag{2, protopack.BytesType}, protopack.Denormalized{+1, protopack.Uvarint(34359738367)}, }.Marshal() proto.Unmarshal(b, new(pb2.MyMessage)) } func TestLengthOverflow(t testing.T) { // Overflowing a length should not panic. b := protopack.Message{ protopack.Tag{2, protopack.BytesType}, protopack.String("\x01"), protopack.Tag{3, protopack.BytesType}, protopack.Uvarint(9223372036854775807), protopack.Raw("\x01"), }.Marshal() proto.Unmarshal(b, new(pb2.MyMessage)) } func TestVarintOverflow(t testing.T) { // Overflowing a 64-bit length should not be allowed. b := protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Varint(1), protopack.Tag{3, protopack.BytesType}, protopack.Raw("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01"), }.Marshal() if err := proto.Unmarshal(b, new(pb2.MyMessage)); err == nil { t.Fatalf("Overflowed uint64 length without error") } } func TestBytesWithInvalidLengthInGroup(t testing.T) { // Overflowing a 64-bit length should not be allowed. b := protopack.Message{ protopack.Tag{775, protopack.StartGroupType}, protopack.Message{ protopack.Tag{774, protopack.BytesType}, protopack.Uvarint(13654841034505509168), protopack.Raw(""), }, }.Marshal() if err := proto.Unmarshal(b, new(pb2.MyMessage)); err == nil { t.Fatalf("Overflowed uint64 length without error") } } func TestUnmarshalFuzz(t testing.T) { const N = 1000 seed := time.Now().UnixNano() t.Logf("RNG seed is %d", seed) rng := rand.New(rand.NewSource(seed)) buf := make([]byte, 20) for i := 0; i < N; i++ { for j := range buf { buf[j] = byte(rng.Intn(256)) } fuzzUnmarshal(t, buf) } } func TestMergeMessages(t testing.T) { pb := &pb2.MessageList{Message: []pb2.MessageList_Message{{Name: proto.String("x"), Count: proto.Int32(1)}}} data, err := proto.Marshal(pb) if err != nil { t.Fatalf("Marshal: %v", err) } pb1 := new(pb2.MessageList) if err := proto.Unmarshal(data, pb1); err != nil { t.Fatalf("first Unmarshal: %v", err) } if err := proto.Unmarshal(data, pb1); err != nil { t.Fatalf("second Unmarshal: %v", err) } if len(pb1.Message) != 1 { t.Errorf("two Unmarshals produced %d Messages, want 1", len(pb1.Message)) } pb2 := new(pb2.MessageList) if err := proto.UnmarshalMerge(data, pb2); err != nil { t.Fatalf("first UnmarshalMerge: %v", err) } if err := proto.UnmarshalMerge(data, pb2); err != nil { t.Fatalf("second UnmarshalMerge: %v", err) } if len(pb2.Message) != 2 { t.Errorf("two UnmarshalMerges produced %d Messages, want 2", len(pb2.Message)) } } func TestExtensionMarshalOrder(t testing.T) { m := &pb2.MyMessage{Count: proto.Int(123)} if err := proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("alpha")}); err != nil { t.Fatalf("SetExtension: %v", err) } if err := proto.SetExtension(m, pb2.E_Ext_Text, proto.String("aleph")); err != nil { t.Fatalf("SetExtension: %v", err) } if err := proto.SetExtension(m, pb2.E_Ext_Number, proto.Int32(1)); err != nil { t.Fatalf("SetExtension: %v", err) } // Serialize m several times, and check we get the same bytes each time. var orig []byte for i := 0; i < 100; i++ { b, err := proto.Marshal(m) if err != nil { t.Fatalf("Marshal: %v", err) } if i == 0 { orig = b continue } if !bytes.Equal(b, orig) { t.Errorf("Bytes differ on attempt #%d", i) } } } func TestExtensionMapFieldMarshalDeterministic(t testing.T) { m := &pb2.MyMessage{Count: proto.Int(123)} if err := proto.SetExtension(m, pb2.E_Ext_More, &pb2.Ext{MapField: map[int32]int32{1: 1, 2: 2, 3: 3, 4: 4}}); err != nil { t.Fatalf("SetExtension: %v", err) } marshal := func(m proto.Message) []byte { var b proto.Buffer b.SetDeterministic(true) if err := b.Marshal(m); err != nil { t.Fatalf("Marshal failed: %v", err) } return b.Bytes() } want := marshal(m) for i := 0; i < 100; i++ { if got := marshal(m); !bytes.Equal(got, want) { t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want) } } } func TestUnmarshalMergesMessages(t testing.T) { // If a nested message occurs twice in the input, // the fields should be merged when decoding. a := &pb2.OtherMessage{ Key: proto.Int64(123), Inner: &pb2.InnerMessage{ Host: proto.String("polhode"), Port: proto.Int32(1234), }, } aData, err := proto.Marshal(a) if err != nil { t.Fatalf("Marshal(a): %v", err) } b := &pb2.OtherMessage{ Weight: proto.Float32(1.2), Inner: &pb2.InnerMessage{ Host: proto.String("herpolhode"), Connected: proto.Bool(true), }, } bData, err := proto.Marshal(b) if err != nil { t.Fatalf("Marshal(b): %v", err) } want := &pb2.OtherMessage{ Key: proto.Int64(123), Weight: proto.Float32(1.2), Inner: &pb2.InnerMessage{ Host: proto.String("herpolhode"), Port: proto.Int32(1234), Connected: proto.Bool(true), }, } got := new(pb2.OtherMessage) if err := proto.Unmarshal(append(aData, bData...), got); err != nil { t.Fatalf("Unmarshal: %v", err) } if !proto.Equal(got, want) { t.Errorf("\n got %v\nwant %v", got, want) } } func TestUnmarshalMergesGroups(t testing.T) { // If a nested group occurs twice in the input, // the fields should be merged when decoding. a := &pb2.GroupNew{ G: &pb2.GroupNew_G{ X: proto.Int32(7), Y: proto.Int32(8), }, } aData, err := proto.Marshal(a) if err != nil { t.Fatalf("Marshal(a): %v", err) } b := &pb2.GroupNew{ G: &pb2.GroupNew_G{ X: proto.Int32(9), }, } bData, err := proto.Marshal(b) if err != nil { t.Fatalf("Marshal(b): %v", err) } want := &pb2.GroupNew{ G: &pb2.GroupNew_G{ X: proto.Int32(9), Y: proto.Int32(8), }, } got := new(pb2.GroupNew) if err := proto.Unmarshal(append(aData, bData...), got); err != nil { t.Fatalf("Unmarshal: %v", err) } if !proto.Equal(got, want) { t.Errorf("\n got %v\nwant %v", got, want) } } func TestEncodingSizes(t testing.T) { tests := []struct { m proto.Message n int }{ {&pb2.Defaults{F_Int32: proto.Int32(math.MaxInt32)}, 6}, {&pb2.Defaults{F_Int32: proto.Int32(math.MinInt32)}, 11}, {&pb2.Defaults{F_Uint32: proto.Uint32(uint32(math.MaxInt32) + 1)}, 6}, {&pb2.Defaults{F_Uint32: proto.Uint32(math.MaxUint32)}, 6}, } for _, test := range tests { b, err := proto.Marshal(test.m) if err != nil { t.Errorf("Marshal(%v): %v", test.m, err) continue } if len(b) != test.n { t.Errorf("Marshal(%v) yielded %d bytes, want %d bytes", test.m, len(b), test.n) } } } func TestRequiredNotSetError(t testing.T) { pb := initGoTest(false) pb.RequiredField.Label = nil pb.F_Int32Required = nil pb.F_Int64Required = nil want := protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(7), protopack.Tag{4, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{2, protopack.BytesType}, protopack.String("type"), }), protopack.Tag{10, protopack.VarintType}, protopack.Bool(true), protopack.Tag{13, protopack.Fixed32Type}, protopack.Uint32(32), protopack.Tag{14, protopack.Fixed64Type}, protopack.Uint64(64), protopack.Tag{15, protopack.VarintType}, protopack.Uvarint(3232), protopack.Tag{16, protopack.VarintType}, protopack.Uvarint(6464), protopack.Tag{17, protopack.Fixed32Type}, protopack.Float32(3232), protopack.Tag{18, protopack.Fixed64Type}, protopack.Float64(6464), protopack.Tag{19, protopack.BytesType}, protopack.String("string"), protopack.Tag{70, protopack.StartGroupType}, protopack.Message{ protopack.Tag{71, protopack.BytesType}, protopack.String("required"), }, protopack.Tag{70, protopack.EndGroupType}, protopack.Tag{101, protopack.BytesType}, protopack.Bytes("bytes"), protopack.Tag{102, protopack.VarintType}, protopack.Svarint(-32), protopack.Tag{103, protopack.VarintType}, protopack.Svarint(-64), protopack.Tag{104, protopack.Fixed32Type}, protopack.Int32(-32), protopack.Tag{105, protopack.Fixed64Type}, protopack.Int64(-64), }.Marshal() got, err := proto.Marshal(pb) if !isRequiredNotSetError(err) { t.Logf("marshal-1 err = %v, want RequiredNotSetError", err) t.Fatalf("got %q\nwant %q", got, want) } if !bytes.Equal(got, want) { t.Fatalf("got %q\nwant %q", got, want) } // Now test Unmarshal by recreating the original buffer. pbd := new(pb2.GoTest) err = proto.Unmarshal(got, pbd) if !isRequiredNotSetError(err) { t.Errorf("unmarshal err = %v, want RequiredNotSetError", err) t.Fatalf("got %q\nwant %q", got, want) } got, err = proto.Marshal(pbd) if !isRequiredNotSetError(err) { t.Errorf("marshal-2 err = %v, want RequiredNotSetError", err) t.Fatalf("got %q\nwant %q", got, want) } if !bytes.Equal(got, want) { t.Fatalf("got %q\nwant %q", got, want) } } func TestRequiredNotSetErrorWithBadWireTypes(t testing.T) { // Required field expects a varint, and properly found a varint. if err := proto.Unmarshal([]byte{0x08, 0x00}, new(pb2.GoEnum)); err != nil { t.Errorf("Unmarshal = %v, want nil", err) } // Required field expects a varint, but found a fixed32 instead. if err := proto.Unmarshal([]byte{0x0d, 0x00, 0x00, 0x00, 0x00}, new(pb2.GoEnum)); err == nil { t.Errorf("Unmarshal = nil, want RequiredNotSetError") } // Required field expects a varint, and found both a varint and fixed32 (ignored). m := new(pb2.GoEnum) if err := proto.Unmarshal([]byte{0x08, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00}, m); err != nil { t.Errorf("Unmarshal = %v, want nil", err) } if !bytes.Equal(m.XXX_unrecognized, []byte{0x0d, 0x00, 0x00, 0x00, 0x00}) { t.Errorf("expected fixed32 to appear as unknown bytes: %x", m.XXX_unrecognized) } } func fuzzUnmarshal(t testing.T, data []byte) { defer func() { if e := recover(); e != nil { t.Errorf("These bytes caused a panic: %+v", data) t.Logf("Stack:\n%s", debug.Stack()) t.FailNow() } }() pb := new(pb2.MyMessage) proto.Unmarshal(data, pb) } func TestMapFieldMarshal(t testing.T) { m := &pb2.MessageWithMap{ NameMapping: map[int32]string{ 1: "Rob", 4: "Ian", 8: "Dave", }, } b, err := proto.Marshal(m) if err != nil { t.Fatalf("Marshal: %v", err) } // b should be the concatenation of these three byte sequences in some order. parts := []string{ "\n\a\b\x01\x12\x03Rob", "\n\a\b\x04\x12\x03Ian", "\n\b\b\x08\x12\x04Dave", } ok := false for i := range parts { for j := range parts { if j == i { continue } for k := range parts { if k == i \|\| k == j { continue } try := parts[i] + parts[j] + parts[k] if bytes.Equal(b, []byte(try)) { ok = true break } } } } if !ok { t.Fatalf("Incorrect Marshal output.\n got %q\nwant %q (or a permutation of that)", b, parts[0]+parts[1]+parts[2]) } t.Logf("FYI b: %q", b) } func TestMapFieldDeterministicMarshal(t testing.T) { m := &pb2.MessageWithMap{ NameMapping: map[int32]string{ 1: "Rob", 4: "Ian", 8: "Dave", }, } marshal := func(m proto.Message) []byte { var b proto.Buffer b.SetDeterministic(true) if err := b.Marshal(m); err != nil { t.Fatalf("Marshal failed: %v", err) } return b.Bytes() } want := marshal(m) for i := 0; i < 10; i++ { if got := marshal(m); !bytes.Equal(got, want) { t.Errorf("Marshal produced inconsistent output with determinism enabled (pass %d).\n got %v\nwant %v", i, got, want) } } } func TestMapFieldRoundTrips(t testing.T) { m := &pb2.MessageWithMap{ NameMapping: map[int32]string{ 1: "Rob", 4: "Ian", 8: "Dave", }, MsgMapping: map[int64]pb2.FloatingPoint{ 0x7001: {F: proto.Float64(2.0)}, }, ByteMapping: map[bool][]byte{ false: []byte("that's not right!"), true: []byte("aye, 'tis true!"), }, } b, err := proto.Marshal(m) if err != nil { t.Fatalf("Marshal: %v", err) } t.Logf("FYI b: %q", b) m2 := new(pb2.MessageWithMap) if err := proto.Unmarshal(b, m2); err != nil { t.Fatalf("Unmarshal: %v", err) } if !proto.Equal(m, m2) { t.Errorf("Map did not survive a round trip.\ninitial: %v\n final: %v", m, m2) } } func TestMapFieldWithNil(t testing.T) { m1 := &pb2.MessageWithMap{ MsgMapping: map[int64]pb2.FloatingPoint{ 1: nil, }, } b, err := proto.Marshal(m1) if _, ok := err.(proto.RequiredNotSetError); !ok { t.Fatalf("Marshal(%v): err=%v, want RequiredNotSet", m1, err) } m2 := new(pb2.MessageWithMap) err = proto.Unmarshal(b, m2) if _, ok := err.(proto.RequiredNotSetError); !ok { t.Fatalf("Unmarshal(%v): err=%v, want RequiredNotSet", m1, err) } if !proto.Equal(m1, m2) { t.Fatalf("roundtrip marshal/unmarshal changed message; got:\n%v\nwant:\n%v", m2, m1) } } func TestMapFieldWithNilBytes(t testing.T) { m1 := &pb2.MessageWithMap{ ByteMapping: map[bool][]byte{ false: {}, true: nil, }, } n := proto.Size(m1) b, err := proto.Marshal(m1) if err != nil { t.Fatalf("Marshal: %v", err) } if n != len(b) { t.Errorf("Size(m1) = %d; want len(Marshal(m1)) = %d", n, len(b)) } m2 := new(pb2.MessageWithMap) if err := proto.Unmarshal(b, m2); err != nil { t.Fatalf("Unmarshal: %v, got these bytes: %v", err, b) } if v, ok := m2.ByteMapping[false]; !ok { t.Error("byte_mapping[false] not present") } else if len(v) != 0 { t.Errorf("byte_mapping[false] not empty: %#v", v) } if v, ok := m2.ByteMapping[true]; !ok { t.Error("byte_mapping[true] not present") } else if len(v) != 0 { t.Errorf("byte_mapping[true] not empty: %#v", v) } } func TestDecodeMapFieldMissingKey(t testing.T) { b := []byte{ 0x0A, 0x03, // message, tag 1 (name_mapping), of length 3 bytes // no key 0x12, 0x01, 0x6D, // string value of length 1 byte, value "m" } got := &pb2.MessageWithMap{} err := proto.Unmarshal(b, got) if err != nil { t.Fatalf("failed to marshal map with missing key: %v", err) } want := &pb2.MessageWithMap{NameMapping: map[int32]string{0: "m"}} if !proto.Equal(got, want) { t.Errorf("Unmarshaled map with no key was not as expected. got: %v, want %v", got, want) } } func TestDecodeMapFieldMissingValue(t testing.T) { b := protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.VarintType}, protopack.Uvarint(1), }), }.Marshal() got := &pb2.MessageWithMap{} err := proto.Unmarshal(b, got) if err != nil { t.Fatalf("failed to marshal map with missing value: %v", err) } want := &pb2.MessageWithMap{NameMapping: map[int32]string{1: ""}} if !proto.Equal(got, want) { t.Errorf("Unmarshaled map with no value was not as expected. got: %v, want %v", got, want) } } func TestOneof(t testing.T) { m := &pb2.Communique{} b, err := proto.Marshal(m) if err != nil { t.Fatalf("Marshal of empty message with oneof: %v", err) } if len(b) != 0 { t.Errorf("Marshal of empty message yielded too many bytes: %v", b) } m = &pb2.Communique{ Union: &pb2.Communique_Name{"Barry"}, } // Round-trip. b, err = proto.Marshal(m) if err != nil { t.Fatalf("Marshal of message with oneof: %v", err) } if len(b) != 7 { // name tag/wire (1) + name len (1) + name (5) t.Errorf("Incorrect marshal of message with oneof: %v", b) } m.Reset() if err := proto.Unmarshal(b, m); err != nil { t.Fatalf("Unmarshal of message with oneof: %v", err) } if x, ok := m.Union.(pb2.Communique_Name); !ok \|\| x.Name != "Barry" { t.Errorf("After round trip, Union = %+v", m.Union) } if name := m.GetName(); name != "Barry" { t.Errorf("After round trip, GetName = %q, want %q", name, "Barry") } // Let's try with a message in the oneof. m.Union = &pb2.Communique_Msg{&pb2.Strings{StringField: proto.String("deep deep string")}} b, err = proto.Marshal(m) if err != nil { t.Fatalf("Marshal of message with oneof set to message: %v", err) } if len(b) != 20 { // msg tag/wire (1) + msg len (1) + msg (1 + 1 + 16) t.Errorf("Incorrect marshal of message with oneof set to message: %v", b) } m.Reset() if err := proto.Unmarshal(b, m); err != nil { t.Fatalf("Unmarshal of message with oneof set to message: %v", err) } ss, ok := m.Union.(pb2.Communique_Msg) if !ok \|\| ss.Msg.GetStringField() != "deep deep string" { t.Errorf("After round trip with oneof set to message, Union = %+v", m.Union) } } func TestOneofNilBytes(t testing.T) { // A oneof with nil byte slice should marshal to tag + 0 (size), with no error. m := &pb2.Communique{Union: &pb2.Communique_Data{Data: nil}} b, err := proto.Marshal(m) if err != nil { t.Fatalf("Marshal failed: %v", err) } want := protopack.Message{ protopack.Tag{7, protopack.BytesType}, protopack.Bytes(""), }.Marshal() if !bytes.Equal(b, want) { t.Errorf("Wrong result of Marshal: got %x, want %x", b, want) } } func TestInefficientPackedBool(t testing.T) { // https://github.com/golang/protobuf/issues/76 inp := protopack.Message{ protopack.Tag{2, protopack.BytesType}, protopack.Bytes("\xb90"), }.Marshal() if err := proto.Unmarshal(inp, new(pb2.MoreRepeated)); err != nil { t.Error(err) } } // Make sure pure-reflect-based implementation handles // []int32-[]enum conversion correctly. func TestRepeatedEnum2(t testing.T) { pb := &pb2.RepeatedEnum{ Color: []pb2.RepeatedEnum_Color{pb2.RepeatedEnum_RED}, } b, err := proto.Marshal(pb) if err != nil { t.Fatalf("Marshal failed: %v", err) } x := new(pb2.RepeatedEnum) err = proto.Unmarshal(b, x) if err != nil { t.Fatalf("Unmarshal failed: %v", err) } if !proto.Equal(pb, x) { t.Errorf("Incorrect result: want: %v got: %v", pb, x) } } // TestConcurrentMarshal makes sure that it is safe to marshal // same message in multiple goroutines concurrently. func TestConcurrentMarshal(t testing.T) { pb := initGoTest(true) const N = 100 b := make([][]byte, N) var wg sync.WaitGroup for i := 0; i < N; i++ { wg.Add(1) go func(i int) { defer wg.Done() var err error b[i], err = proto.Marshal(pb) if err != nil { t.Errorf("marshal error: %v", err) } }(i) } wg.Wait() for i := 1; i < N; i++ { if !bytes.Equal(b[0], b[i]) { t.Errorf("concurrent marshal result not same: b[0] = %v, b[%d] = %v", b[0], i, b[i]) } } } func TestInvalidUTF8(t testing.T) { const invalidUTF8 = "\xde\xad\xbe\xef\x80\x00\xff" tests := []struct { label string proto2 proto.Message proto3 proto.Message want []byte }{{ label: "Scalar", proto2: &pb2.TestUTF8{Scalar: proto.String(invalidUTF8)}, proto3: &pb3.TestUTF8{Scalar: invalidUTF8}, want: []byte{0x0a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff}, }, { label: "Vector", proto2: &pb2.TestUTF8{Vector: []string{invalidUTF8}}, proto3: &pb3.TestUTF8{Vector: []string{invalidUTF8}}, want: []byte{0x12, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff}, }, { label: "Oneof", proto2: &pb2.TestUTF8{Oneof: &pb2.TestUTF8_Field{invalidUTF8}}, proto3: &pb3.TestUTF8{Oneof: &pb3.TestUTF8_Field{invalidUTF8}}, want: []byte{0x1a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff}, }, { label: "MapKey", proto2: &pb2.TestUTF8{MapKey: map[string]int64{invalidUTF8: 0}}, proto3: &pb3.TestUTF8{MapKey: map[string]int64{invalidUTF8: 0}}, want: []byte{0x22, 0x0b, 0x0a, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff, 0x10, 0x00}, }, { label: "MapValue", proto2: &pb2.TestUTF8{MapValue: map[int64]string{0: invalidUTF8}}, proto3: &pb3.TestUTF8{MapValue: map[int64]string{0: invalidUTF8}}, want: []byte{0x2a, 0x0b, 0x08, 0x00, 0x12, 0x07, 0xde, 0xad, 0xbe, 0xef, 0x80, 0x00, 0xff}, }} for _, tt := range tests { // Proto2 should not validate UTF-8. b, err := proto.Marshal(tt.proto2) if err != nil { t.Errorf("Marshal(proto2.%s) = %v, want nil", tt.label, err) } if !bytes.Equal(b, tt.want) { t.Errorf("Marshal(proto2.%s) = %x, want %x", tt.label, b, tt.want) } m := proto.Clone(tt.proto2) m.Reset() if err = proto.Unmarshal(tt.want, m); err != nil { t.Errorf("Unmarshal(proto2.%s) = %v, want nil", tt.label, err) } if !proto.Equal(m, tt.proto2) { t.Errorf("proto2.%s: output mismatch:\ngot %v\nwant %v", tt.label, m, tt.proto2) } // Proto3 should validate UTF-8. if _, err := proto.Marshal(tt.proto3); err == nil { t.Errorf("Marshal(proto3.%s) = %v, want non-nil", tt.label, err) } m = proto.Clone(tt.proto3) m.Reset() if err := proto.Unmarshal(tt.want, m); err == nil { t.Errorf("Unmarshal(proto3.%s) = %v, want non-nil", tt.label, err) } } } func TestRequired(t testing.T) { // The F_BoolRequired field appears after all of the required fields. // It should still be handled even after multiple required field violations. m := &pb2.GoTest{F_BoolRequired: proto.Bool(true)} got, err := proto.Marshal(m) if !isRequiredNotSetError(err) { t.Errorf("Marshal() = %v, want RequiredNotSetError error", err) } if want := []byte{0x50, 0x01}; !bytes.Equal(got, want) { t.Errorf("Marshal() = %x, want %x", got, want) } m = new(pb2.GoTest) err = proto.Unmarshal(got, m) if !isRequiredNotSetError(err) { t.Errorf("Marshal() = %v, want RequiredNotSetError error", err) } if !m.GetF_BoolRequired() { t.Error("m.F_BoolRequired = false, want true") } } func TestUnknownV2(t testing.T) { m := new(tspb.Timestamp) m.ProtoReflect().SetUnknown([]byte("\x92\x4d\x12unknown field 1234")) got := proto.CompactTextString(m) if !strings.Contains(got, "unknown field 1234") { t.Errorf("got %q, want contains %q", got, "unknown field 1234") } } func testMsg() pb2.GoTest { pb := initGoTest(true) const N = 1000 // Internally the library starts much smaller. pb.F_Int32Repeated = make([]int32, N) pb.F_DoubleRepeated = make([]float64, N) for i := 0; i < N; i++ { pb.F_Int32Repeated[i] = int32(i) pb.F_DoubleRepeated[i] = float64(i) } return pb } func bytesMsg() pb2.GoTest { pb := initGoTest(true) buf := make([]byte, 4000) for i := range buf { buf[i] = byte(i) } pb.F_BytesDefaulted = buf return pb } func benchmarkMarshal(b testing.B, pb proto.Message, marshal func(proto.Message) ([]byte, error)) { d, _ := marshal(pb) b.SetBytes(int64(len(d))) b.ResetTimer() for i := 0; i < b.N; i++ { marshal(pb) } } func benchmarkBufferMarshal(b testing.B, pb proto.Message) { p := proto.NewBuffer(nil) benchmarkMarshal(b, pb, func(pb0 proto.Message) ([]byte, error) { p.Reset() err := p.Marshal(pb0) return p.Bytes(), err }) } func benchmarkSize(b testing.B, pb proto.Message) { benchmarkMarshal(b, pb, func(pb0 proto.Message) ([]byte, error) { proto.Size(pb) return nil, nil }) } func TestProto3ZeroValues(t testing.T) { tests := []struct { desc string m proto.Message }{ {"zero message", &pb3.Message{}}, {"empty bytes field", &pb3.Message{Data: []byte{}}}, } for _, test := range tests { b, err := proto.Marshal(test.m) if err != nil { t.Errorf("%s: proto.Marshal: %v", test.desc, err) continue } if len(b) > 0 { t.Errorf("%s: Encoding is non-empty: %q", test.desc, b) } } } func TestRoundTripProto3(t testing.T) { m := &pb3.Message{ Name: "David", // (2 \| 1<<3): 0x0a 0x05 "David" Hilarity: pb3.Message_PUNS, // (0 \| 2<<3): 0x10 0x01 HeightInCm: 178, // (0 \| 3<<3): 0x18 0xb2 0x01 Data: []byte("roboto"), // (2 \| 4<<3): 0x20 0x06 "roboto" ResultCount: 47, // (0 \| 7<<3): 0x38 0x2f TrueScotsman: true, // (0 \| 8<<3): 0x40 0x01 Score: 8.1, // (5 \| 9<<3): 0x4d <8.1> Key: []uint64{1, 0xdeadbeef}, Nested: &pb3.Nested{ Bunny: "Monty", }, } t.Logf(" m: %v", m) b, err := proto.Marshal(m) if err != nil { t.Fatalf("proto.Marshal: %v", err) } t.Logf(" b: %q", b) m2 := new(pb3.Message) if err := proto.Unmarshal(b, m2); err != nil { t.Fatalf("proto.Unmarshal: %v", err) } t.Logf("m2: %v", m2) if !proto.Equal(m, m2) { t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2) } } func TestGettersForBasicTypesExist(t testing.T) { var m pb3.Message if got := m.GetNested().GetBunny(); got != "" { t.Errorf("m.GetNested().GetBunny() = %q, want empty string", got) } if got := m.GetNested().GetCute(); got { t.Errorf("m.GetNested().GetCute() = %t, want false", got) } } func TestProto3SetDefaults(t testing.T) { in := &pb3.Message{ Terrain: map[string]pb3.Nested{ "meadow": new(pb3.Nested), }, Proto2Field: new(pb2.SubDefaults), Proto2Value: map[string]pb2.SubDefaults{ "badlands": new(pb2.SubDefaults), }, } got := proto.Clone(in).(pb3.Message) proto.SetDefaults(got) // There are no defaults in proto3. Everything should be the zero value, but // we need to remember to set defaults for nested proto2 messages. want := &pb3.Message{ Terrain: map[string]pb3.Nested{ "meadow": new(pb3.Nested), }, Proto2Field: &pb2.SubDefaults{N: proto.Int64(7)}, Proto2Value: map[string]pb2.SubDefaults{ "badlands": &pb2.SubDefaults{N: proto.Int64(7)}, }, } if !proto.Equal(got, want) { t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want) } } func TestUnknownFieldPreservation(t testing.T) { b1 := "\x0a\x05David" // Known tag 1 b2 := "\xc2\x0c\x06Google" // Unknown tag 200 b := []byte(b1 + b2) m := new(pb3.Message) if err := proto.Unmarshal(b, m); err != nil { t.Fatalf("proto.Unmarshal: %v", err) } if !bytes.Equal(m.XXX_unrecognized, []byte(b2)) { t.Fatalf("mismatching unknown fields:\ngot %q\nwant %q", m.XXX_unrecognized, b2) } } func TestMap(t testing.T) { b := protopack.Message{ protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("Key1"), protopack.Tag{2, protopack.BytesType}, protopack.String("Val1"), }), protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("Key2"), protopack.Tag{2, protopack.BytesType}, protopack.String("Val2a"), protopack.Tag{2, protopack.BytesType}, protopack.String("Val2"), }), protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("Key3"), protopack.Tag{1, protopack.Fixed32Type}, protopack.Uint32(5), protopack.Tag{2, protopack.BytesType}, protopack.String("Val3b"), protopack.Tag{3, protopack.BytesType}, protopack.Bytes("Val3a"), protopack.Tag{2, protopack.BytesType}, protopack.String("Val3"), protopack.Tag{2, protopack.Fixed32Type}, protopack.Uint32(5), }), protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix{}, protopack.Tag{20, protopack.BytesType}, protopack.LengthPrefix(protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.String("Key4"), protopack.Tag{2, protopack.StartGroupType}, protopack.Message{ protopack.Tag{1, protopack.BytesType}, protopack.Bytes("SomeURL"), protopack.Tag{2, protopack.BytesType}, protopack.Bytes("SomeTitle"), protopack.Tag{3, protopack.BytesType}, protopack.Bytes("Snippet1"), }, protopack.Tag{2, protopack.EndGroupType}, }), }.Marshal() var m pb3.Message if err := proto.Unmarshal(b, &m); err != nil { t.Fatalf("proto.Unmarshal error: %v", err) } got := m.StringMap want := map[string]string{ "": "", "Key1": "Val1", "Key2": "Val2", "Key3": "Val3", "Key4": "", } if !reflect.DeepEqual(got, want) { t.Errorf("maps differ:\ngot %#v\nwant %#v", got, want) } } func marshalled() []byte { m := &pb3.IntMaps{} for i := 0; i < 1000; i++ { m.Maps = append(m.Maps, &pb3.IntMap{ Rtt: map[int32]int32{1: 2}, }) } b, err := proto.Marshal(m) if err != nil { panic(fmt.Sprintf("Can't marshal %+v: %v", m, err)) } return b } var messageWithExtension1 = &pb2.MyMessage{Count: proto.Int32(7)} // messageWithExtension2 is in equal_test.go. var messageWithExtension3 = &pb2.MyMessage{Count: proto.Int32(8)} func init() { if err := proto.SetExtension(messageWithExtension1, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("Abbott")}); err != nil { log.Panicf("proto.SetExtension: %v", err) } if err := proto.SetExtension(messageWithExtension3, pb2.E_Ext_More, &pb2.Ext{Data: proto.String("Costello")}); err != nil { log.Panicf("proto.SetExtension: %v", err) } // Force messageWithExtension3 to have the extension encoded. proto.Marshal(messageWithExtension3) } // non-pointer custom message type nonptrMessage struct{} func (m nonptrMessage) ProtoMessage() {} func (m nonptrMessage) Reset() {} func (m nonptrMessage) String() string { return "" } func (m nonptrMessage) Marshal() ([]byte, error) { return []byte{42}, nil } var SizeTests = []struct { desc string pb proto.Message }{ {"empty", &pb2.OtherMessage{}}, // Basic types. {"bool", &pb2.Defaults{F_Bool: proto.Bool(true)}}, {"int32", &pb2.Defaults{F_Int32: proto.Int32(12)}}, {"negative int32", &pb2.Defaults{F_Int32: proto.Int32(-1)}}, {"small int64", &pb2.Defaults{F_Int64: proto.Int64(1)}}, {"big int64", &pb2.Defaults{F_Int64: proto.Int64(1 << 20)}}, {"negative int64", &pb2.Defaults{F_Int64: proto.Int64(-1)}}, {"fixed32", &pb2.Defaults{F_Fixed32: proto.Uint32(71)}}, {"fixed64", &pb2.Defaults{F_Fixed64: proto.Uint64(72)}}, {"uint32", &pb2.Defaults{F_Uint32: proto.Uint32(123)}}, {"uint64", &pb2.Defaults{F_Uint64: proto.Uint64(124)}}, {"float", &pb2.Defaults{F_Float: proto.Float32(12.6)}}, {"double", &pb2.Defaults{F_Double: proto.Float64(13.9)}}, {"string", &pb2.Defaults{F_String: proto.String("niles")}}, {"bytes", &pb2.Defaults{F_Bytes: []byte("wowsa")}}, {"bytes, empty", &pb2.Defaults{F_Bytes: []byte{}}}, {"sint32", &pb2.Defaults{F_Sint32: proto.Int32(65)}}, {"sint64", &pb2.Defaults{F_Sint64: proto.Int64(67)}}, {"enum", &pb2.Defaults{F_Enum: pb2.Defaults_BLUE.Enum()}}, // Repeated. {"empty repeated bool", &pb2.MoreRepeated{Bools: []bool{}}}, {"repeated bool", &pb2.MoreRepeated{Bools: []bool{false, true, true, false}}}, {"packed repeated bool", &pb2.MoreRepeated{BoolsPacked: []bool{false, true, true, false, true, true, true}}}, {"repeated int32", &pb2.MoreRepeated{Ints: []int32{1, 12203, 1729, -1}}}, {"repeated int32 packed", &pb2.MoreRepeated{IntsPacked: []int32{1, 12203, 1729}}}, {"repeated int64 packed", &pb2.MoreRepeated{Int64SPacked: []int64{ // Need enough large numbers to verify that the header is counting the number of bytes // for the field, not the number of elements. 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, }}}, {"repeated string", &pb2.MoreRepeated{Strings: []string{"r", "ken", "gri"}}}, {"repeated fixed", &pb2.MoreRepeated{Fixeds: []uint32{1, 2, 3, 4}}}, // Nested. {"nested", &pb2.OldMessage{Nested: &pb2.OldMessage_Nested{Name: proto.String("whatever")}}}, {"group", &pb2.GroupOld{G: &pb2.GroupOld_G{X: proto.Int32(12345)}}}, // Other things. {"unrecognized", &pb2.MoreRepeated{XXX_unrecognized: []byte{13<<3 \| 0, 4}}}, {"extension (unencoded)", messageWithExtension1}, {"extension (encoded)", messageWithExtension3}, // proto3 message {"proto3 empty", &pb3.Message{}}, {"proto3 bool", &pb3.Message{TrueScotsman: true}}, {"proto3 int64", &pb3.Message{ResultCount: 1}}, {"proto3 uint32", &pb3.Message{HeightInCm: 123}}, {"proto3 float", &pb3.Message{Score: 12.6}}, {"proto3 string", &pb3.Message{Name: "Snezana"}}, {"proto3 bytes", &pb3.Message{Data: []byte("wowsa")}}, {"proto3 bytes, empty", &pb3.Message{Data: []byte{}}}, {"proto3 enum", &pb3.Message{Hilarity: pb3.Message_PUNS}}, {"proto3 map field with empty bytes", &pb3.MessageWithMap{ByteMapping: map[bool][]byte{false: []byte{}}}}, {"map field", &pb2.MessageWithMap{NameMapping: map[int32]string{1: "Rob", 7: "Andrew"}}}, {"map field with message", &pb2.MessageWithMap{MsgMapping: map[int64]pb2.FloatingPoint{0x7001: &pb2.FloatingPoint{F: proto.Float64(2.0)}}}}, {"map field with bytes", &pb2.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte("this time for sure")}}}, {"map field with empty bytes", &pb2.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte{}}}}, {"map field with big entry", &pb2.MessageWithMap{NameMapping: map[int32]string{8: strings.Repeat("x", 125)}}}, {"map field with big key and val", &pb2.MessageWithMap{StrToStr: map[string]string{strings.Repeat("x", 70): strings.Repeat("y", 70)}}}, {"map field with big numeric key", &pb2.MessageWithMap{NameMapping: map[int32]string{0xf00d: "om nom nom"}}}, {"oneof not set", &pb2.Oneof{}}, {"oneof bool", &pb2.Oneof{Union: &pb2.Oneof_F_Bool{true}}}, {"oneof zero int32", &pb2.Oneof{Union: &pb2.Oneof_F_Int32{0}}}, {"oneof big int32", &pb2.Oneof{Union: &pb2.Oneof_F_Int32{1 << 20}}}, {"oneof int64", &pb2.Oneof{Union: &pb2.Oneof_F_Int64{42}}}, {"oneof fixed32", &pb2.Oneof{Union: &pb2.Oneof_F_Fixed32{43}}}, {"oneof fixed64", &pb2.Oneof{Union: &pb2.Oneof_F_Fixed64{44}}}, {"oneof uint32", &pb2.Oneof{Union: &pb2.Oneof_F_Uint32{45}}}, {"oneof uint64", &pb2.Oneof{Union: &pb2.Oneof_F_Uint64{46}}}, {"oneof float", &pb2.Oneof{Union: &pb2.Oneof_F_Float{47.1}}}, {"oneof double", &pb2.Oneof{Union: &pb2.Oneof_F_Double{48.9}}}, {"oneof string", &pb2.Oneof{Union: &pb2.Oneof_F_String{"Rhythmic Fman"}}}, {"oneof bytes", &pb2.Oneof{Union: &pb2.Oneof_F_Bytes{[]byte("let go")}}}, {"oneof sint32", &pb2.Oneof{Union: &pb2.Oneof_F_Sint32{50}}}, {"oneof sint64", &pb2.Oneof{Union: &pb2.Oneof_F_Sint64{51}}}, {"oneof enum", &pb2.Oneof{Union: &pb2.Oneof_F_Enum{pb2.MyMessage_BLUE}}}, {"message for oneof", &pb2.GoTestField{Label: proto.String("k"), Type: proto.String("v")}}, {"oneof message", &pb2.Oneof{Union: &pb2.Oneof_F_Message{&pb2.GoTestField{Label: proto.String("k"), Type: proto.String("v")}}}}, {"oneof group", &pb2.Oneof{Union: &pb2.Oneof_FGroup{&pb2.Oneof_F_Group{X: proto.Int32(52)}}}}, {"oneof largest tag", &pb2.Oneof{Union: &pb2.Oneof_F_Largest_Tag{1}}}, {"multiple oneofs", &pb2.Oneof{Union: &pb2.Oneof_F_Int32{1}, Tormato: &pb2.Oneof_Value{2}}}, {"non-pointer message", nonptrMessage{}}, } func TestSize(t testing.T) { for _, tc := range SizeTests { t.Run(tc.desc, func(t testing.T) { size := proto.Size(tc.pb) b, err := proto.Marshal(tc.pb) if err != nil { t.Errorf("%v: Marshal failed: %v", tc.desc, err) return } if size != len(b) { t.Errorf("%v: Size(%v) = %d, want %d", tc.desc, tc.pb, size, len(b)) t.Logf("%v: bytes: %#v", tc.desc, b) } }) } } func TestVarintSize(t testing.T) { // Check the edge cases carefully. testCases := []struct { n uint64 size int }{ {0, 1}, {1, 1}, {127, 1}, {128, 2}, {16383, 2}, {16384, 3}, {math.MaxInt64, 9}, {math.MaxInt64 + 1, 10}, } for _, tc := range testCases { size := proto.SizeVarint(tc.n) if size != tc.size { t.Errorf("sizeVarint(%d) = %d, want %d", tc.n, size, tc.size) } } }	88.59 KB	2025-05-25 12:27
📄 registry.go // 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 import ( "bytes" "compress/gzip" "fmt" "io/ioutil" "reflect" "strings" "sync" "google.golang.org/protobuf/reflect/protodesc" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/runtime/protoimpl" ) // filePath is the path to the proto source file. type filePath = string // e.g., "google/protobuf/descriptor.proto" // fileDescGZIP is the compressed contents of the encoded FileDescriptorProto. type fileDescGZIP = []byte var fileCache sync.Map // map[filePath]fileDescGZIP // RegisterFile is called from generated code to register the compressed // FileDescriptorProto with the file path for a proto source file. // // Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead. func RegisterFile(s filePath, d fileDescGZIP) { // Decompress the descriptor. zr, err := gzip.NewReader(bytes.NewReader(d)) if err != nil { panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err)) } b, err := ioutil.ReadAll(zr) if err != nil { panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err)) } // Construct a protoreflect.FileDescriptor from the raw descriptor. // Note that DescBuilder.Build automatically registers the constructed // file descriptor with the v2 registry. protoimpl.DescBuilder{RawDescriptor: b}.Build() // Locally cache the raw descriptor form for the file. fileCache.Store(s, d) } // FileDescriptor returns the compressed FileDescriptorProto given the file path // for a proto source file. It returns nil if not found. // // Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead. func FileDescriptor(s filePath) fileDescGZIP { if v, ok := fileCache.Load(s); ok { return v.(fileDescGZIP) } // Find the descriptor in the v2 registry. var b []byte if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil { b, _ = Marshal(protodesc.ToFileDescriptorProto(fd)) } // Locally cache the raw descriptor form for the file. if len(b) > 0 { v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b)) return v.(fileDescGZIP) } return nil } // enumName is the name of an enum. For historical reasons, the enum name is // neither the full Go name nor the full protobuf name of the enum. // The name is the dot-separated combination of just the proto package that the // enum is declared within followed by the Go type name of the generated enum. type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum" // enumsByName maps enum values by name to their numeric counterpart. type enumsByName = map[string]int32 // enumsByNumber maps enum values by number to their name counterpart. type enumsByNumber = map[int32]string var enumCache sync.Map // map[enumName]enumsByName var numFilesCache sync.Map // map[protoreflect.FullName]int // RegisterEnum is called from the generated code to register the mapping of // enum value names to enum numbers for the enum identified by s. // // Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead. func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) { if _, ok := enumCache.Load(s); ok { panic("proto: duplicate enum registered: " + s) } enumCache.Store(s, m) // This does not forward registration to the v2 registry since this API // lacks sufficient information to construct a complete v2 enum descriptor. } // EnumValueMap returns the mapping from enum value names to enum numbers for // the enum of the given name. It returns nil if not found. // // Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead. func EnumValueMap(s enumName) enumsByName { if v, ok := enumCache.Load(s); ok { return v.(enumsByName) } // Check whether the cache is stale. If the number of files in the current // package differs, then it means that some enums may have been recently // registered upstream that we do not know about. var protoPkg protoreflect.FullName if i := strings.LastIndexByte(s, '.'); i >= 0 { protoPkg = protoreflect.FullName(s[:i]) } v, _ := numFilesCache.Load(protoPkg) numFiles, _ := v.(int) if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles { return nil // cache is up-to-date; was not found earlier } // Update the enum cache for all enums declared in the given proto package. numFiles = 0 protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool { walkEnums(fd, func(ed protoreflect.EnumDescriptor) { name := protoimpl.X.LegacyEnumName(ed) if _, ok := enumCache.Load(name); !ok { m := make(enumsByName) evs := ed.Values() for i := evs.Len() - 1; i >= 0; i-- { ev := evs.Get(i) m[string(ev.Name())] = int32(ev.Number()) } enumCache.LoadOrStore(name, m) } }) numFiles++ return true }) numFilesCache.Store(protoPkg, numFiles) // Check cache again for enum map. if v, ok := enumCache.Load(s); ok { return v.(enumsByName) } return nil } // walkEnums recursively walks all enums declared in d. func walkEnums(d interface { Enums() protoreflect.EnumDescriptors Messages() protoreflect.MessageDescriptors }, f func(protoreflect.EnumDescriptor)) { eds := d.Enums() for i := eds.Len() - 1; i >= 0; i-- { f(eds.Get(i)) } mds := d.Messages() for i := mds.Len() - 1; i >= 0; i-- { walkEnums(mds.Get(i), f) } } // messageName is the full name of protobuf message. type messageName = string var messageTypeCache sync.Map // map[messageName]reflect.Type // RegisterType is called from generated code to register the message Go type // for a message of the given name. // // Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead. func RegisterType(m Message, s messageName) { mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s)) if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil { panic(err) } messageTypeCache.Store(s, reflect.TypeOf(m)) } // RegisterMapType is called from generated code to register the Go map type // for a protobuf message representing a map entry. // // Deprecated: Do not use. func RegisterMapType(m interface{}, s messageName) { t := reflect.TypeOf(m) if t.Kind() != reflect.Map { panic(fmt.Sprintf("invalid map kind: %v", t)) } if _, ok := messageTypeCache.Load(s); ok { panic(fmt.Errorf("proto: duplicate proto message registered: %s", s)) } messageTypeCache.Store(s, t) } // MessageType returns the message type for a named message. // It returns nil if not found. // // Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead. func MessageType(s messageName) reflect.Type { if v, ok := messageTypeCache.Load(s); ok { return v.(reflect.Type) } // Derive the message type from the v2 registry. var t reflect.Type if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil { t = messageGoType(mt) } // If we could not get a concrete type, it is possible that it is a // pseudo-message for a map entry. if t == nil { d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s)) if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() { kt := goTypeForField(md.Fields().ByNumber(1)) vt := goTypeForField(md.Fields().ByNumber(2)) t = reflect.MapOf(kt, vt) } } // Locally cache the message type for the given name. if t != nil { v, _ := messageTypeCache.LoadOrStore(s, t) return v.(reflect.Type) } return nil } func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type { switch k := fd.Kind(); k { case protoreflect.EnumKind: if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil { return enumGoType(et) } return reflect.TypeOf(protoreflect.EnumNumber(0)) case protoreflect.MessageKind, protoreflect.GroupKind: if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil { return messageGoType(mt) } return reflect.TypeOf((protoreflect.Message)(nil)).Elem() default: return reflect.TypeOf(fd.Default().Interface()) } } func enumGoType(et protoreflect.EnumType) reflect.Type { return reflect.TypeOf(et.New(0)) } func messageGoType(mt protoreflect.MessageType) reflect.Type { return reflect.TypeOf(MessageV1(mt.Zero().Interface())) } // MessageName returns the full protobuf name for the given message type. // // Deprecated: Use protoreflect.MessageDescriptor.FullName instead. func MessageName(m Message) messageName { if m == nil { return "" } if m, ok := m.(interface{ XXX_MessageName() messageName }); ok { return m.XXX_MessageName() } return messageName(protoimpl.X.MessageDescriptorOf(m).FullName()) } // RegisterExtension is called from the generated code to register // the extension descriptor. // // Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead. func RegisterExtension(d ExtensionDesc) { if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil { panic(err) } } type extensionsByNumber = map[int32]ExtensionDesc var extensionCache sync.Map // map[messageName]extensionsByNumber // RegisteredExtensions returns a map of the registered extensions for the // provided protobuf message, indexed by the extension field number. // // Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead. func RegisteredExtensions(m Message) extensionsByNumber { // Check whether the cache is stale. If the number of extensions for // the given message differs, then it means that some extensions were // recently registered upstream that we do not know about. s := MessageName(m) v, _ := extensionCache.Load(s) xs, _ := v.(extensionsByNumber) if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) { return xs // cache is up-to-date } // Cache is stale, re-compute the extensions map. xs = make(extensionsByNumber) protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool { if xd, ok := xt.(ExtensionDesc); ok { xs[int32(xt.TypeDescriptor().Number())] = xd } else { // TODO: This implies that the protoreflect.ExtensionType is a // custom type not generated by protoc-gen-go. We could try and // convert the type to an ExtensionDesc. } return true }) extensionCache.Store(s, xs) return xs }	10.26 KB	2025-05-25 12:27
📄 registry_test.go // 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 ( "reflect" "testing" "github.com/golang/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" descpb "github.com/golang/protobuf/protoc-gen-go/descriptor" ) func TestRegistry(t *testing.T) { file := new(descpb.DescriptorProto).ProtoReflect().Descriptor().ParentFile() path := file.Path() pkg := file.Package() if got := proto.FileDescriptor(path); len(got) == 0 { t.Errorf("FileDescriptor(%q) = empty, want non-empty", path) } name := protoreflect.FullName(pkg + ".FieldDescriptorProto_Label") if got := proto.EnumValueMap(string(name)); len(got) == 0 { t.Errorf("EnumValueMap(%q) = empty, want non-empty", name) } msg := new(descpb.EnumDescriptorProto_EnumReservedRange) name = msg.ProtoReflect().Descriptor().FullName() wantType := reflect.TypeOf(msg) gotType := proto.MessageType(string(name)) if gotType != wantType { t.Errorf("MessageType(%q) = %v, want %v", name, gotType, wantType) } }	1.1 KB	2025-05-25 12:27
📄 text_decode.go // Copyright 2010 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 import ( "encoding" "errors" "fmt" "reflect" "strconv" "strings" "unicode/utf8" "google.golang.org/protobuf/encoding/prototext" protoV2 "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" ) const wrapTextUnmarshalV2 = false // ParseError is returned by UnmarshalText. type ParseError struct { Message string // Deprecated: Do not use. Line, Offset int } func (e ParseError) Error() string { if wrapTextUnmarshalV2 { return e.Message } if e.Line == 1 { return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message) } return fmt.Sprintf("line %d: %v", e.Line, e.Message) } // UnmarshalText parses a proto text formatted string into m. func UnmarshalText(s string, m Message) error { if u, ok := m.(encoding.TextUnmarshaler); ok { return u.UnmarshalText([]byte(s)) } m.Reset() mi := MessageV2(m) if wrapTextUnmarshalV2 { err := prototext.UnmarshalOptions{ AllowPartial: true, }.Unmarshal([]byte(s), mi) if err != nil { return &ParseError{Message: err.Error()} } return checkRequiredNotSet(mi) } else { if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil { return err } return checkRequiredNotSet(mi) } } type textParser struct { s string // remaining input done bool // whether the parsing is finished (success or error) backed bool // whether back() was called offset, line int cur token } type token struct { value string err ParseError line int // line number offset int // byte number from start of input, not start of line unquoted string // the unquoted version of value, if it was a quoted string } func newTextParser(s string) textParser { p := new(textParser) p.s = s p.line = 1 p.cur.line = 1 return p } func (p textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) { md := m.Descriptor() fds := md.Fields() // A struct is a sequence of "name: value", terminated by one of // '>' or '}', or the end of the input. A name may also be // "[extension]" or "[type/url]". // // The whole struct can also be an expanded Any message, like: // [type/url] < ... struct contents ... > seen := make(map[protoreflect.FieldNumber]bool) for { tok := p.next() if tok.err != nil { return tok.err } if tok.value == terminator { break } if tok.value == "[" { if err := p.unmarshalExtensionOrAny(m, seen); err != nil { return err } continue } // This is a normal, non-extension field. name := protoreflect.Name(tok.value) fd := fds.ByName(name) switch { case fd == nil: gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name)))) if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name { fd = gd } case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name: fd = nil case fd.IsWeak() && fd.Message().IsPlaceholder(): fd = nil } if fd == nil { typeName := string(md.FullName()) if m, ok := m.Interface().(Message); ok { t := reflect.TypeOf(m) if t.Kind() == reflect.Ptr { typeName = t.Elem().String() } } return p.errorf("unknown field name %q in %v", name, typeName) } if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil { return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name()) } if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] { return p.errorf("non-repeated field %q was repeated", fd.Name()) } seen[fd.Number()] = true // Consume any colon. if err := p.checkForColon(fd); err != nil { return err } // Parse into the field. v := m.Get(fd) if !m.Has(fd) && (fd.IsList() \|\| fd.IsMap() \|\| fd.Message() != nil) { v = m.Mutable(fd) } if v, err = p.unmarshalValue(v, fd); err != nil { return err } m.Set(fd, v) if err := p.consumeOptionalSeparator(); err != nil { return err } } return nil } func (p textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error { name, err := p.consumeExtensionOrAnyName() if err != nil { return err } // If it contains a slash, it's an Any type URL. if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 { tok := p.next() if tok.err != nil { return tok.err } // consume an optional colon if tok.value == ":" { tok = p.next() if tok.err != nil { return tok.err } } var terminator string switch tok.value { case "<": terminator = ">" case "{": terminator = "}" default: return p.errorf("expected '{' or '<', found %q", tok.value) } mt, err := protoregistry.GlobalTypes.FindMessageByURL(name) if err != nil { return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):]) } m2 := mt.New() if err := p.unmarshalMessage(m2, terminator); err != nil { return err } b, err := protoV2.Marshal(m2.Interface()) if err != nil { return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err) } urlFD := m.Descriptor().Fields().ByName("type_url") valFD := m.Descriptor().Fields().ByName("value") if seen[urlFD.Number()] { return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name()) } if seen[valFD.Number()] { return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name()) } m.Set(urlFD, protoreflect.ValueOfString(name)) m.Set(valFD, protoreflect.ValueOfBytes(b)) seen[urlFD.Number()] = true seen[valFD.Number()] = true return nil } xname := protoreflect.FullName(name) xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname) if xt == nil && isMessageSet(m.Descriptor()) { xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension")) } if xt == nil { return p.errorf("unrecognized extension %q", name) } fd := xt.TypeDescriptor() if fd.ContainingMessage().FullName() != m.Descriptor().FullName() { return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName()) } if err := p.checkForColon(fd); err != nil { return err } v := m.Get(fd) if !m.Has(fd) && (fd.IsList() \|\| fd.IsMap() \|\| fd.Message() != nil) { v = m.Mutable(fd) } v, err = p.unmarshalValue(v, fd) if err != nil { return err } m.Set(fd, v) return p.consumeOptionalSeparator() } func (p textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { tok := p.next() if tok.err != nil { return v, tok.err } if tok.value == "" { return v, p.errorf("unexpected EOF") } switch { case fd.IsList(): lv := v.List() var err error if tok.value == "[" { // Repeated field with list notation, like [1,2,3]. for { vv := lv.NewElement() vv, err = p.unmarshalSingularValue(vv, fd) if err != nil { return v, err } lv.Append(vv) tok := p.next() if tok.err != nil { return v, tok.err } if tok.value == "]" { break } if tok.value != "," { return v, p.errorf("Expected ']' or ',' found %q", tok.value) } } return v, nil } // One value of the repeated field. p.back() vv := lv.NewElement() vv, err = p.unmarshalSingularValue(vv, fd) if err != nil { return v, err } lv.Append(vv) return v, nil case fd.IsMap(): // The map entry should be this sequence of tokens: // < key : KEY value : VALUE > // However, implementations may omit key or value, and technically // we should support them in any order. var terminator string switch tok.value { case "<": terminator = ">" case "{": terminator = "}" default: return v, p.errorf("expected '{' or '<', found %q", tok.value) } keyFD := fd.MapKey() valFD := fd.MapValue() mv := v.Map() kv := keyFD.Default() vv := mv.NewValue() for { tok := p.next() if tok.err != nil { return v, tok.err } if tok.value == terminator { break } var err error switch tok.value { case "key": if err := p.consumeToken(":"); err != nil { return v, err } if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil { return v, err } if err := p.consumeOptionalSeparator(); err != nil { return v, err } case "value": if err := p.checkForColon(valFD); err != nil { return v, err } if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil { return v, err } if err := p.consumeOptionalSeparator(); err != nil { return v, err } default: p.back() return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) } } mv.Set(kv.MapKey(), vv) return v, nil default: p.back() return p.unmarshalSingularValue(v, fd) } } func (p textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { tok := p.next() if tok.err != nil { return v, tok.err } if tok.value == "" { return v, p.errorf("unexpected EOF") } switch fd.Kind() { case protoreflect.BoolKind: switch tok.value { case "true", "1", "t", "True": return protoreflect.ValueOfBool(true), nil case "false", "0", "f", "False": return protoreflect.ValueOfBool(false), nil } case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { return protoreflect.ValueOfInt32(int32(x)), nil } // The C++ parser accepts large positive hex numbers that uses // two's complement arithmetic to represent negative numbers. // This feature is here for backwards compatibility with C++. if strings.HasPrefix(tok.value, "0x") { if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil } } case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { return protoreflect.ValueOfInt64(int64(x)), nil } // The C++ parser accepts large positive hex numbers that uses // two's complement arithmetic to represent negative numbers. // This feature is here for backwards compatibility with C++. if strings.HasPrefix(tok.value, "0x") { if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil } } case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { return protoreflect.ValueOfUint32(uint32(x)), nil } case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { return protoreflect.ValueOfUint64(uint64(x)), nil } case protoreflect.FloatKind: // Ignore 'f' for compatibility with output generated by C++, // but don't remove 'f' when the value is "-inf" or "inf". v := tok.value if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" { v = v[:len(v)-len("f")] } if x, err := strconv.ParseFloat(v, 32); err == nil { return protoreflect.ValueOfFloat32(float32(x)), nil } case protoreflect.DoubleKind: // Ignore 'f' for compatibility with output generated by C++, // but don't remove 'f' when the value is "-inf" or "inf". v := tok.value if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" { v = v[:len(v)-len("f")] } if x, err := strconv.ParseFloat(v, 64); err == nil { return protoreflect.ValueOfFloat64(float64(x)), nil } case protoreflect.StringKind: if isQuote(tok.value[0]) { return protoreflect.ValueOfString(tok.unquoted), nil } case protoreflect.BytesKind: if isQuote(tok.value[0]) { return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil } case protoreflect.EnumKind: if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil } vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value)) if vd != nil { return protoreflect.ValueOfEnum(vd.Number()), nil } case protoreflect.MessageKind, protoreflect.GroupKind: var terminator string switch tok.value { case "{": terminator = "}" case "<": terminator = ">" default: return v, p.errorf("expected '{' or '<', found %q", tok.value) } err := p.unmarshalMessage(v.Message(), terminator) return v, err default: panic(fmt.Sprintf("invalid kind %v", fd.Kind())) } return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value) } // Consume a ':' from the input stream (if the next token is a colon), // returning an error if a colon is needed but not present. func (p textParser) checkForColon(fd protoreflect.FieldDescriptor) ParseError { tok := p.next() if tok.err != nil { return tok.err } if tok.value != ":" { if fd.Message() == nil { return p.errorf("expected ':', found %q", tok.value) } p.back() } return nil } // consumeExtensionOrAnyName consumes an extension name or an Any type URL and // the following ']'. It returns the name or URL consumed. func (p textParser) consumeExtensionOrAnyName() (string, error) { tok := p.next() if tok.err != nil { return "", tok.err } // If extension name or type url is quoted, it's a single token. if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) if err != nil { return "", err } return name, p.consumeToken("]") } // Consume everything up to "]" var parts []string for tok.value != "]" { parts = append(parts, tok.value) tok = p.next() if tok.err != nil { return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) } if p.done && tok.value != "]" { return "", p.errorf("unclosed type_url or extension name") } } return strings.Join(parts, ""), nil } // consumeOptionalSeparator consumes an optional semicolon or comma. // It is used in unmarshalMessage to provide backward compatibility. func (p textParser) consumeOptionalSeparator() error { tok := p.next() if tok.err != nil { return tok.err } if tok.value != ";" && tok.value != "," { p.back() } return nil } func (p textParser) errorf(format string, a ...interface{}) ParseError { pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} p.cur.err = pe p.done = true return pe } func (p textParser) skipWhitespace() { i := 0 for i < len(p.s) && (isWhitespace(p.s[i]) \|\| p.s[i] == '#') { if p.s[i] == '#' { // comment; skip to end of line or input for i < len(p.s) && p.s[i] != '\n' { i++ } if i == len(p.s) { break } } if p.s[i] == '\n' { p.line++ } i++ } p.offset += i p.s = p.s[i:len(p.s)] if len(p.s) == 0 { p.done = true } } func (p textParser) advance() { // Skip whitespace p.skipWhitespace() if p.done { return } // Start of non-whitespace p.cur.err = nil p.cur.offset, p.cur.line = p.offset, p.line p.cur.unquoted = "" switch p.s[0] { case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': // Single symbol p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] case '"', '\'': // Quoted string i := 1 for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { if p.s[i] == '\\' && i+1 < len(p.s) { // skip escaped char i++ } i++ } if i >= len(p.s) \|\| p.s[i] != p.s[0] { p.errorf("unmatched quote") return } unq, err := unquoteC(p.s[1:i], rune(p.s[0])) if err != nil { p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) return } p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] p.cur.unquoted = unq default: i := 0 for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { i++ } if i == 0 { p.errorf("unexpected byte %#x", p.s[0]) return } p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] } p.offset += len(p.cur.value) } // Back off the parser by one token. Can only be done between calls to next(). // It makes the next advance() a no-op. func (p textParser) back() { p.backed = true } // Advances the parser and returns the new current token. func (p textParser) next() token { if p.backed \|\| p.done { p.backed = false return &p.cur } p.advance() if p.done { p.cur.value = "" } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { // Look for multiple quoted strings separated by whitespace, // and concatenate them. cat := p.cur for { p.skipWhitespace() if p.done \|\| !isQuote(p.s[0]) { break } p.advance() if p.cur.err != nil { return &p.cur } cat.value += " " + p.cur.value cat.unquoted += p.cur.unquoted } p.done = false // parser may have seen EOF, but we want to return cat p.cur = cat } return &p.cur } func (p textParser) consumeToken(s string) error { tok := p.next() if tok.err != nil { return tok.err } if tok.value != s { p.back() return p.errorf("expected %q, found %q", s, tok.value) } return nil } var errBadUTF8 = errors.New("proto: bad UTF-8") func unquoteC(s string, quote rune) (string, error) { // This is based on C++'s tokenizer.cc. // Despite its name, this is not* parsing C syntax. // For instance, "\0" is an invalid quoted string. // Avoid allocation in trivial cases. simple := true for _, r := range s { if r == '\\' \|\| r == quote { simple = false break } } if simple { return s, nil } buf := make([]byte, 0, 3*len(s)/2) for len(s) > 0 { r, n := utf8.DecodeRuneInString(s) if r == utf8.RuneError && n == 1 { return "", errBadUTF8 } s = s[n:] if r != '\\' { if r < utf8.RuneSelf { buf = append(buf, byte(r)) } else { buf = append(buf, string(r)...) } continue } ch, tail, err := unescape(s) if err != nil { return "", err } buf = append(buf, ch...) s = tail } return string(buf), nil } func unescape(s string) (ch string, tail string, err error) { r, n := utf8.DecodeRuneInString(s) if r == utf8.RuneError && n == 1 { return "", "", errBadUTF8 } s = s[n:] switch r { case 'a': return "\a", s, nil case 'b': return "\b", s, nil case 'f': return "\f", s, nil case 'n': return "\n", s, nil case 'r': return "\r", s, nil case 't': return "\t", s, nil case 'v': return "\v", s, nil case '?': return "?", s, nil // trigraph workaround case '\'', '"', '\\': return string(r), s, nil case '0', '1', '2', '3', '4', '5', '6', '7': if len(s) < 2 { return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) } ss := string(r) + s[:2] s = s[2:] i, err := strconv.ParseUint(ss, 8, 8) if err != nil { return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss) } return string([]byte{byte(i)}), s, nil case 'x', 'X', 'u', 'U': var n int switch r { case 'x', 'X': n = 2 case 'u': n = 4 case 'U': n = 8 } if len(s) < n { return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n) } ss := s[:n] s = s[n:] i, err := strconv.ParseUint(ss, 16, 64) if err != nil { return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss) } if r == 'x' \|\| r == 'X' { return string([]byte{byte(i)}), s, nil } if i > utf8.MaxRune { return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss) } return string(rune(i)), s, nil } return "", "", fmt.Errorf(`unknown escape \%c`, r) } func isIdentOrNumberChar(c byte) bool { switch { case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': return true case '0' <= c && c <= '9': return true } switch c { case '-', '+', '.', '_': return true } return false } func isWhitespace(c byte) bool { switch c { case ' ', '\t', '\n', '\r': return true } return false } func isQuote(c byte) bool { switch c { case '"', '\'': return true } return false }	19.63 KB	2025-05-25 12:27
📄 text_encode.go // Copyright 2010 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 import ( "bytes" "encoding" "fmt" "io" "math" "sort" "strings" "google.golang.org/protobuf/encoding/prototext" "google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" ) const wrapTextMarshalV2 = false // TextMarshaler is a configurable text format marshaler. type TextMarshaler struct { Compact bool // use compact text format (one line) ExpandAny bool // expand google.protobuf.Any messages of known types } // Marshal writes the proto text format of m to w. func (tm TextMarshaler) Marshal(w io.Writer, m Message) error { b, err := tm.marshal(m) if len(b) > 0 { if _, err := w.Write(b); err != nil { return err } } return err } // Text returns a proto text formatted string of m. func (tm TextMarshaler) Text(m Message) string { b, _ := tm.marshal(m) return string(b) } func (tm TextMarshaler) marshal(m Message) ([]byte, error) { mr := MessageReflect(m) if mr == nil \|\| !mr.IsValid() { return []byte("<nil>"), nil } if wrapTextMarshalV2 { if m, ok := m.(encoding.TextMarshaler); ok { return m.MarshalText() } opts := prototext.MarshalOptions{ AllowPartial: true, EmitUnknown: true, } if !tm.Compact { opts.Indent = " " } if !tm.ExpandAny { opts.Resolver = (protoregistry.Types)(nil) } return opts.Marshal(mr.Interface()) } else { w := &textWriter{ compact: tm.Compact, expandAny: tm.ExpandAny, complete: true, } if m, ok := m.(encoding.TextMarshaler); ok { b, err := m.MarshalText() if err != nil { return nil, err } w.Write(b) return w.buf, nil } err := w.writeMessage(mr) return w.buf, err } } var ( defaultTextMarshaler = TextMarshaler{} compactTextMarshaler = TextMarshaler{Compact: true} ) // MarshalText writes the proto text format of m to w. func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) } // MarshalTextString returns a proto text formatted string of m. func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) } // CompactText writes the compact proto text format of m to w. func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) } // CompactTextString returns a compact proto text formatted string of m. func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) } var ( newline = []byte("\n") endBraceNewline = []byte("}\n") posInf = []byte("inf") negInf = []byte("-inf") nan = []byte("nan") ) // textWriter is an io.Writer that tracks its indentation level. type textWriter struct { compact bool // same as TextMarshaler.Compact expandAny bool // same as TextMarshaler.ExpandAny complete bool // whether the current position is a complete line indent int // indentation level; never negative buf []byte } func (w textWriter) Write(p []byte) (n int, _ error) { newlines := bytes.Count(p, newline) if newlines == 0 { if !w.compact && w.complete { w.writeIndent() } w.buf = append(w.buf, p...) w.complete = false return len(p), nil } frags := bytes.SplitN(p, newline, newlines+1) if w.compact { for i, frag := range frags { if i > 0 { w.buf = append(w.buf, ' ') n++ } w.buf = append(w.buf, frag...) n += len(frag) } return n, nil } for i, frag := range frags { if w.complete { w.writeIndent() } w.buf = append(w.buf, frag...) n += len(frag) if i+1 < len(frags) { w.buf = append(w.buf, '\n') n++ } } w.complete = len(frags[len(frags)-1]) == 0 return n, nil } func (w textWriter) WriteByte(c byte) error { if w.compact && c == '\n' { c = ' ' } if !w.compact && w.complete { w.writeIndent() } w.buf = append(w.buf, c) w.complete = c == '\n' return nil } func (w textWriter) writeName(fd protoreflect.FieldDescriptor) { if !w.compact && w.complete { w.writeIndent() } w.complete = false if fd.Kind() != protoreflect.GroupKind { w.buf = append(w.buf, fd.Name()...) w.WriteByte(':') } else { // Use message type name for group field name. w.buf = append(w.buf, fd.Message().Name()...) } if !w.compact { w.WriteByte(' ') } } func requiresQuotes(u string) bool { // When type URL contains any characters except [0-9A-Za-z./\-], it must be quoted. for _, ch := range u { switch { case ch == '.' \|\| ch == '/' \|\| ch == '_': continue case '0' <= ch && ch <= '9': continue case 'A' <= ch && ch <= 'Z': continue case 'a' <= ch && ch <= 'z': continue default: return true } } return false } // writeProto3Any writes an expanded google.protobuf.Any message. // // It returns (false, nil) if sv value can't be unmarshaled (e.g. because // required messages are not linked in). // // It returns (true, error) when sv was written in expanded format or an error // was encountered. func (w textWriter) writeProto3Any(m protoreflect.Message) (bool, error) { md := m.Descriptor() fdURL := md.Fields().ByName("type_url") fdVal := md.Fields().ByName("value") url := m.Get(fdURL).String() mt, err := protoregistry.GlobalTypes.FindMessageByURL(url) if err != nil { return false, nil } b := m.Get(fdVal).Bytes() m2 := mt.New() if err := proto.Unmarshal(b, m2.Interface()); err != nil { return false, nil } w.Write([]byte("[")) if requiresQuotes(url) { w.writeQuotedString(url) } else { w.Write([]byte(url)) } if w.compact { w.Write([]byte("]:<")) } else { w.Write([]byte("]: <\n")) w.indent++ } if err := w.writeMessage(m2); err != nil { return true, err } if w.compact { w.Write([]byte("> ")) } else { w.indent-- w.Write([]byte(">\n")) } return true, nil } func (w textWriter) writeMessage(m protoreflect.Message) error { md := m.Descriptor() if w.expandAny && md.FullName() == "google.protobuf.Any" { if canExpand, err := w.writeProto3Any(m); canExpand { return err } } fds := md.Fields() for i := 0; i < fds.Len(); { fd := fds.Get(i) if od := fd.ContainingOneof(); od != nil { fd = m.WhichOneof(od) i += od.Fields().Len() } else { i++ } if fd == nil \|\| !m.Has(fd) { continue } switch { case fd.IsList(): lv := m.Get(fd).List() for j := 0; j < lv.Len(); j++ { w.writeName(fd) v := lv.Get(j) if err := w.writeSingularValue(v, fd); err != nil { return err } w.WriteByte('\n') } case fd.IsMap(): kfd := fd.MapKey() vfd := fd.MapValue() mv := m.Get(fd).Map() type entry struct{ key, val protoreflect.Value } var entries []entry mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool { entries = append(entries, entry{k.Value(), v}) return true }) sort.Slice(entries, func(i, j int) bool { switch kfd.Kind() { case protoreflect.BoolKind: return !entries[i].key.Bool() && entries[j].key.Bool() case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: return entries[i].key.Int() < entries[j].key.Int() case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind: return entries[i].key.Uint() < entries[j].key.Uint() case protoreflect.StringKind: return entries[i].key.String() < entries[j].key.String() default: panic("invalid kind") } }) for _, entry := range entries { w.writeName(fd) w.WriteByte('<') if !w.compact { w.WriteByte('\n') } w.indent++ w.writeName(kfd) if err := w.writeSingularValue(entry.key, kfd); err != nil { return err } w.WriteByte('\n') w.writeName(vfd) if err := w.writeSingularValue(entry.val, vfd); err != nil { return err } w.WriteByte('\n') w.indent-- w.WriteByte('>') w.WriteByte('\n') } default: w.writeName(fd) if err := w.writeSingularValue(m.Get(fd), fd); err != nil { return err } w.WriteByte('\n') } } if b := m.GetUnknown(); len(b) > 0 { w.writeUnknownFields(b) } return w.writeExtensions(m) } func (w textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error { switch fd.Kind() { case protoreflect.FloatKind, protoreflect.DoubleKind: switch vf := v.Float(); { case math.IsInf(vf, +1): w.Write(posInf) case math.IsInf(vf, -1): w.Write(negInf) case math.IsNaN(vf): w.Write(nan) default: fmt.Fprint(w, v.Interface()) } case protoreflect.StringKind: // NOTE: This does not validate UTF-8 for historical reasons. w.writeQuotedString(string(v.String())) case protoreflect.BytesKind: w.writeQuotedString(string(v.Bytes())) case protoreflect.MessageKind, protoreflect.GroupKind: var bra, ket byte = '<', '>' if fd.Kind() == protoreflect.GroupKind { bra, ket = '{', '}' } w.WriteByte(bra) if !w.compact { w.WriteByte('\n') } w.indent++ m := v.Message() if m2, ok := m.Interface().(encoding.TextMarshaler); ok { b, err := m2.MarshalText() if err != nil { return err } w.Write(b) } else { w.writeMessage(m) } w.indent-- w.WriteByte(ket) case protoreflect.EnumKind: if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil { fmt.Fprint(w, ev.Name()) } else { fmt.Fprint(w, v.Enum()) } default: fmt.Fprint(w, v.Interface()) } return nil } // writeQuotedString writes a quoted string in the protocol buffer text format. func (w textWriter) writeQuotedString(s string) { w.WriteByte('"') for i := 0; i < len(s); i++ { switch c := s[i]; c { case '\n': w.buf = append(w.buf, `\n`...) case '\r': w.buf = append(w.buf, `\r`...) case '\t': w.buf = append(w.buf, `\t`...) case '"': w.buf = append(w.buf, `\"`...) case '\\': w.buf = append(w.buf, `\\`...) default: if isPrint := c >= 0x20 && c < 0x7f; isPrint { w.buf = append(w.buf, c) } else { w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...) } } } w.WriteByte('"') } func (w textWriter) writeUnknownFields(b []byte) { if !w.compact { fmt.Fprintf(w, "/ %d unknown bytes /\n", len(b)) } for len(b) > 0 { num, wtyp, n := protowire.ConsumeTag(b) if n < 0 { return } b = b[n:] if wtyp == protowire.EndGroupType { w.indent-- w.Write(endBraceNewline) continue } fmt.Fprint(w, num) if wtyp != protowire.StartGroupType { w.WriteByte(':') } if !w.compact \|\| wtyp == protowire.StartGroupType { w.WriteByte(' ') } switch wtyp { case protowire.VarintType: v, n := protowire.ConsumeVarint(b) if n < 0 { return } b = b[n:] fmt.Fprint(w, v) case protowire.Fixed32Type: v, n := protowire.ConsumeFixed32(b) if n < 0 { return } b = b[n:] fmt.Fprint(w, v) case protowire.Fixed64Type: v, n := protowire.ConsumeFixed64(b) if n < 0 { return } b = b[n:] fmt.Fprint(w, v) case protowire.BytesType: v, n := protowire.ConsumeBytes(b) if n < 0 { return } b = b[n:] fmt.Fprintf(w, "%q", v) case protowire.StartGroupType: w.WriteByte('{') w.indent++ default: fmt.Fprintf(w, "/ unknown wire type %d /", wtyp) } w.WriteByte('\n') } } // writeExtensions writes all the extensions in m. func (w textWriter) writeExtensions(m protoreflect.Message) error { md := m.Descriptor() if md.ExtensionRanges().Len() == 0 { return nil } type ext struct { desc protoreflect.FieldDescriptor val protoreflect.Value } var exts []ext m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { if fd.IsExtension() { exts = append(exts, ext{fd, v}) } return true }) sort.Slice(exts, func(i, j int) bool { return exts[i].desc.Number() < exts[j].desc.Number() }) for _, ext := range exts { // For message set, use the name of the message as the extension name. name := string(ext.desc.FullName()) if isMessageSet(ext.desc.ContainingMessage()) { name = strings.TrimSuffix(name, ".message_set_extension") } if !ext.desc.IsList() { if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil { return err } } else { lv := ext.val.List() for i := 0; i < lv.Len(); i++ { if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil { return err } } } } return nil } func (w textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error { fmt.Fprintf(w, "[%s]:", name) if !w.compact { w.WriteByte(' ') } if err := w.writeSingularValue(v, fd); err != nil { return err } w.WriteByte('\n') return nil } func (w textWriter) writeIndent() { if !w.complete { return } for i := 0; i < w.indent*2; i++ { w.buf = append(w.buf, ' ') } w.complete = false }	12.74 KB	2025-05-25 12:27
📄 text_test.go // 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"`), { in: `[proto2_test.complex]:<>`, err: `line 1.20: extension field "proto2_test.complex" does not extend message "proto2_test.MyMessage"`, }, // 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) } }	33.15 KB	2025-05-25 12:27
📄 wire.go // 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 import ( protoV2 "google.golang.org/protobuf/proto" "google.golang.org/protobuf/runtime/protoiface" ) // Size returns the size in bytes of the wire-format encoding of m. func Size(m Message) int { if m == nil { return 0 } mi := MessageV2(m) return protoV2.Size(mi) } // Marshal returns the wire-format encoding of m. func Marshal(m Message) ([]byte, error) { b, err := marshalAppend(nil, m, false) if b == nil { b = zeroBytes } return b, err } var zeroBytes = make([]byte, 0, 0) func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) { if m == nil { return nil, ErrNil } mi := MessageV2(m) nbuf, err := protoV2.MarshalOptions{ Deterministic: deterministic, AllowPartial: true, }.MarshalAppend(buf, mi) if err != nil { return buf, err } if len(buf) == len(nbuf) { if !mi.ProtoReflect().IsValid() { return buf, ErrNil } } return nbuf, checkRequiredNotSet(mi) } // Unmarshal parses a wire-format message in b and places the decoded results in m. // // Unmarshal resets m before starting to unmarshal, so any existing data in m is always // removed. Use UnmarshalMerge to preserve and append to existing data. func Unmarshal(b []byte, m Message) error { m.Reset() return UnmarshalMerge(b, m) } // UnmarshalMerge parses a wire-format message in b and places the decoded results in m. func UnmarshalMerge(b []byte, m Message) error { mi := MessageV2(m) out, err := protoV2.UnmarshalOptions{ AllowPartial: true, Merge: true, }.UnmarshalState(protoiface.UnmarshalInput{ Buf: b, Message: mi.ProtoReflect(), }) if err != nil { return err } if out.Flags&protoiface.UnmarshalInitialized > 0 { return nil } return checkRequiredNotSet(mi) }	1.86 KB	2025-05-25 12:27
📄 wrappers.go // 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 // Bool stores v in a new bool value and returns a pointer to it. func Bool(v bool) bool { return &v } // Int stores v in a new int32 value and returns a pointer to it. // // Deprecated: Use Int32 instead. func Int(v int) int32 { return Int32(int32(v)) } // Int32 stores v in a new int32 value and returns a pointer to it. func Int32(v int32) int32 { return &v } // Int64 stores v in a new int64 value and returns a pointer to it. func Int64(v int64) int64 { return &v } // Uint32 stores v in a new uint32 value and returns a pointer to it. func Uint32(v uint32) uint32 { return &v } // Uint64 stores v in a new uint64 value and returns a pointer to it. func Uint64(v uint64) uint64 { return &v } // Float32 stores v in a new float32 value and returns a pointer to it. func Float32(v float32) float32 { return &v } // Float64 stores v in a new float64 value and returns a pointer to it. func Float64(v float64) float64 { return &v } // String stores v in a new string value and returns a pointer to it. func String(v string) *string { return &v }	1.21 KB	2025-05-25 12:27

Edit File:

Terminal