potyarkin/frostfs-api-go
1
0
Fork 0
forked from TrueCloudLab/frostfs-api-go
Code Pull requests Activity

Add stable marshal helpers for repeated fields

Browse source 
Signed-off-by: Alex Vanin <alexey@nspcc.ru>
This commit is contained in:
Alex Vanin 2020-08-14 17:22:47 +03:00 committed by Stanislav Bogatyrev
parent a7a8fc33bb
commit a68252c956
4 changed files with 1217 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

159
util/proto/marshal.go
View file

@ -128,6 +128,165 @@ func EnumSize(field int, v int32) int {
return UInt64Size(field, uint64(v))
}
func RepeatedBytesMarshal(field int, buf []byte, v [][]byte) (int, error) {
var offset int
for i := range v {
off, err := BytesMarshal(field, buf[offset:], v[i])
if err != nil {
return 0, err
}
offset += off
}
return offset, nil
}
func RepeatedBytesSize(field int, v [][]byte) (size int) {
for i := range v {
size += BytesSize(field, v[i])
}
return size
}
func RepeatedStringMarshal(field int, buf []byte, v []string) (int, error) {
var offset int
for i := range v {
off, err := StringMarshal(field, buf[offset:], v[i])
if err != nil {
return 0, err
}
offset += off
}
return offset, nil
}
func RepeatedStringSize(field int, v []string) (size int) {
for i := range v {
size += StringSize(field, v[i])
}
return size
}
func RepeatedUInt64Marshal(field int, buf []byte, v []uint64) (int, error) {
if len(v) == 0 {
return 0, nil
}
prefix := field<<3 | 0x02
offset := binary.PutUvarint(buf, uint64(prefix))
_, arrSize := RepeatedUInt64Size(field, v)
offset += binary.PutUvarint(buf[offset:], uint64(arrSize))
for i := range v {
offset += binary.PutUvarint(buf[offset:], v[i])
}
return offset, nil
}
func RepeatedUInt64Size(field int, v []uint64) (size, arraySize int) {
if len(v) == 0 {
return 0, 0
}
for i := range v {
size += VarUIntSize(v[i])
}
arraySize = size
size += VarUIntSize(uint64(size))
prefix := field<<3 | 0x2
size += VarUIntSize(uint64(prefix))
return size, arraySize
}
func RepeatedInt64Marshal(field int, buf []byte, v []int64) (int, error) {
if len(v) == 0 {
return 0, nil
}
convert := make([]uint64, len(v))
for i := range v {
convert[i] = uint64(v[i])
}
return RepeatedUInt64Marshal(field, buf, convert)
}
func RepeatedInt64Size(field int, v []int64) (size, arraySize int) {
if len(v) == 0 {
return 0, 0
}
convert := make([]uint64, len(v))
for i := range v {
convert[i] = uint64(v[i])
}
return RepeatedUInt64Size(field, convert)
}
func RepeatedUInt32Marshal(field int, buf []byte, v []uint32) (int, error) {
if len(v) == 0 {
return 0, nil
}
convert := make([]uint64, len(v))
for i := range v {
convert[i] = uint64(v[i])
}
return RepeatedUInt64Marshal(field, buf, convert)
}
func RepeatedUInt32Size(field int, v []uint32) (size, arraySize int) {
if len(v) == 0 {
return 0, 0
}
convert := make([]uint64, len(v))
for i := range v {
convert[i] = uint64(v[i])
}
return RepeatedUInt64Size(field, convert)
}
func RepeatedInt32Marshal(field int, buf []byte, v []int32) (int, error) {
if len(v) == 0 {
return 0, nil
}
convert := make([]uint64, len(v))
for i := range v {
convert[i] = uint64(v[i])
}
return RepeatedUInt64Marshal(field, buf, convert)
}
func RepeatedInt32Size(field int, v []int32) (size, arraySize int) {
if len(v) == 0 {
return 0, 0
}
convert := make([]uint64, len(v))
for i := range v {
convert[i] = uint64(v[i])
}
return RepeatedUInt64Size(field, convert)
}
// varUIntSize returns length of varint byte sequence for uint64 value 'x'.
func VarUIntSize(x uint64) int {
return (bits.Len64(x|1) + 6) / 7

467
util/proto/marshal_test.go
View file

@ -23,6 +23,15 @@ type stablePrimitives struct {
FieldH SomeEnum
}
type stableRepPrimitives struct {
FieldA [][]byte
FieldB []string
FieldC []int32
FieldD []uint32
FieldE []int64
FieldF []uint64
}
const (
ENUM_UNKNOWN SomeEnum = 0
ENUM_POSITIVE = 1
@ -118,7 +127,7 @@ func (s *stablePrimitives) stableMarshal(buf []byte, wrongField bool) ([]byte, e
}
offset, err = proto.EnumMarshal(fieldNum, buf, int32(s.FieldH))
if err != nil {
return nil, errors.Wrap(err, "can't marshal field g")
return nil, errors.Wrap(err, "can't marshal field h")
}
i += offset
@ -136,6 +145,93 @@ func (s *stablePrimitives) stableSize() int {
proto.EnumSize(300, int32(s.FieldH))
}
func (s *stableRepPrimitives) stableMarshal(buf []byte, wrongField bool) ([]byte, error) {
if s == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, s.stableSize())
}
var (
i, offset, fieldNum int
)
fieldNum = 1
if wrongField {
fieldNum++
}
offset, err := proto.RepeatedBytesMarshal(fieldNum, buf, s.FieldA)
if err != nil {
return nil, errors.Wrap(err, "can't marshal field a")
}
i += offset
fieldNum = 2
if wrongField {
fieldNum++
}
offset, err = proto.RepeatedStringMarshal(fieldNum, buf, s.FieldB)
if err != nil {
return nil, errors.Wrap(err, "can't marshal field b")
}
i += offset
fieldNum = 3
if wrongField {
fieldNum++
}
offset, err = proto.RepeatedInt32Marshal(fieldNum, buf, s.FieldC)
if err != nil {
return nil, errors.Wrap(err, "can't marshal field c")
}
i += offset
fieldNum = 4
if wrongField {
fieldNum++
}
offset, err = proto.RepeatedUInt32Marshal(fieldNum, buf, s.FieldD)
if err != nil {
return nil, errors.Wrap(err, "can't marshal field d")
}
i += offset
fieldNum = 5
if wrongField {
fieldNum++
}
offset, err = proto.RepeatedInt64Marshal(fieldNum, buf, s.FieldE)
if err != nil {
return nil, errors.Wrap(err, "can't marshal field e")
}
i += offset
fieldNum = 6
if wrongField {
fieldNum++
}
offset, err = proto.RepeatedUInt64Marshal(fieldNum, buf, s.FieldF)
if err != nil {
return nil, errors.Wrap(err, "can't marshal field f")
}
i += offset
return buf, nil
}
func (s *stableRepPrimitives) stableSize() int {
f1 := proto.RepeatedBytesSize(1, s.FieldA)
f2 := proto.RepeatedStringSize(2, s.FieldB)
f3, _ := proto.RepeatedInt32Size(3, s.FieldC)
f4, _ := proto.RepeatedUInt32Size(4, s.FieldD)
f5, _ := proto.RepeatedInt64Size(5, s.FieldE)
f6, _ := proto.RepeatedUInt64Size(6, s.FieldF)
return f1 + f2 + f3 + f4 + f5 + f6
}
func TestBytesMarshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := []byte("Hello World")
@ -237,112 +333,103 @@ func TestEnumMarshal(t *testing.T) {
testEnumMarshal(t, ENUM_NEGATIVE, true)
}
func testBytesMarshal(t *testing.T, data []byte, wrongField bool) {
var (
wire []byte
err error
func TestRepeatedBytesMarshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := [][]byte{[]byte("One"), []byte("Two"), []byte("Three")}
testRepeatedBytesMarshal(t, data, false)
testRepeatedBytesMarshal(t, data, true)
})
custom = stablePrimitives{FieldA: data}
transport = test.Primitives{FieldA: data}
)
t.Run("empty", func(t *testing.T) {
testRepeatedBytesMarshal(t, [][]byte{}, false)
})
wire, err = custom.stableMarshal(nil, wrongField)
require.NoError(t, err)
wireGen, err := transport.Marshal()
require.NoError(t, err)
if !wrongField {
// we can check equality because single field cannot be unstable marshalled
require.Equal(t, wireGen, wire)
} else {
require.NotEqual(t, wireGen, wire)
}
result := new(test.Primitives)
err = result.Unmarshal(wire)
require.NoError(t, err)
if !wrongField {
require.Len(t, result.FieldA, len(data))
if len(data) > 0 {
require.Equal(t, data, result.FieldA)
}
} else {
require.Len(t, result.FieldA, 0)
}
t.Run("nil", func(t *testing.T) {
testRepeatedBytesMarshal(t, nil, false)
})
}
func testStringMarshal(t *testing.T, s string, wrongField bool) {
var (
wire []byte
err error
func TestRepeatedStringMarshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := []string{"One", "Two", "Three"}
testRepeatedStringMarshal(t, data, false)
testRepeatedStringMarshal(t, data, true)
})
custom = stablePrimitives{FieldB: s}
transport = test.Primitives{FieldB: s}
)
t.Run("empty", func(t *testing.T) {
testRepeatedStringMarshal(t, []string{}, false)
})
wire, err = custom.stableMarshal(nil, wrongField)
require.NoError(t, err)
wireGen, err := transport.Marshal()
require.NoError(t, err)
if !wrongField {
// we can check equality because single field cannot be unstable marshalled
require.Equal(t, wireGen, wire)
} else {
require.NotEqual(t, wireGen, wire)
}
result := new(test.Primitives)
err = result.Unmarshal(wire)
require.NoError(t, err)
if !wrongField {
require.Len(t, result.FieldB, len(s))
if len(s) > 0 {
require.Equal(t, s, result.FieldB)
}
} else {
require.Len(t, result.FieldB, 0)
}
t.Run("nil", func(t *testing.T) {
testRepeatedStringMarshal(t, nil, false)
})
}
func testBoolMarshal(t *testing.T, b bool, wrongField bool) {
var (
wire []byte
err error
func TestRepeatedInt32Marshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := []int32{-1, 0, 1, 2, 3, 4, 5}
testRepeatedInt32Marshal(t, data, false)
testRepeatedInt32Marshal(t, data, true)
})
custom = stablePrimitives{FieldC: b}
transport = test.Primitives{FieldC: b}
)
t.Run("empty", func(t *testing.T) {
testRepeatedInt32Marshal(t, []int32{}, false)
})
wire, err = custom.stableMarshal(nil, wrongField)
require.NoError(t, err)
wireGen, err := transport.Marshal()
require.NoError(t, err)
if !wrongField {
// we can check equality because single field cannot be unstable marshalled
require.Equal(t, wireGen, wire)
} else {
require.NotEqual(t, wireGen, wire)
}
result := new(test.Primitives)
err = result.Unmarshal(wire)
require.NoError(t, err)
if !wrongField {
require.Equal(t, b, result.FieldC)
} else {
require.False(t, false, result.FieldC)
}
t.Run("nil", func(t *testing.T) {
testRepeatedInt32Marshal(t, nil, false)
})
}
func testIntMarshal(t *testing.T, c stablePrimitives, tr test.Primitives, wrongField bool) *test.Primitives {
func TestRepeatedUInt32Marshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := []uint32{0, 1, 2, 3, 4, 5}
testRepeatedUInt32Marshal(t, data, false)
testRepeatedUInt32Marshal(t, data, true)
})
t.Run("empty", func(t *testing.T) {
testRepeatedUInt32Marshal(t, []uint32{}, false)
})
t.Run("nil", func(t *testing.T) {
testRepeatedUInt32Marshal(t, nil, false)
})
}
func TestRepeatedInt64Marshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := []int64{-1, 0, 1, 2, 3, 4, 5}
testRepeatedInt64Marshal(t, data, false)
testRepeatedInt64Marshal(t, data, true)
})
t.Run("empty", func(t *testing.T) {
testRepeatedInt64Marshal(t, []int64{}, false)
})
t.Run("nil", func(t *testing.T) {
testRepeatedInt64Marshal(t, nil, false)
})
}
func TestRepeatedUInt64Marshal(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
data := []uint64{0, 1, 2, 3, 4, 5}
testRepeatedUInt64Marshal(t, data, false)
testRepeatedUInt64Marshal(t, data, true)
})
t.Run("empty", func(t *testing.T) {
testRepeatedUInt64Marshal(t, []uint64{}, false)
})
t.Run("nil", func(t *testing.T) {
testRepeatedUInt64Marshal(t, nil, false)
})
}
func testMarshal(t *testing.T, c stablePrimitives, tr test.Primitives, wrongField bool) *test.Primitives {
var (
wire []byte
err error
@ -367,13 +454,64 @@ func testIntMarshal(t *testing.T, c stablePrimitives, tr test.Primitives, wrongF
return result
}
func testBytesMarshal(t *testing.T, data []byte, wrongField bool) {
var (
custom = stablePrimitives{FieldA: data}
transport = test.Primitives{FieldA: data}
)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldA, len(data))
if len(data) > 0 {
require.Equal(t, data, result.FieldA)
}
} else {
require.Len(t, result.FieldA, 0)
}
}
func testStringMarshal(t *testing.T, s string, wrongField bool) {
var (
custom = stablePrimitives{FieldB: s}
transport = test.Primitives{FieldB: s}
)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldB, len(s))
if len(s) > 0 {
require.Equal(t, s, result.FieldB)
}
} else {
require.Len(t, result.FieldB, 0)
}
}
func testBoolMarshal(t *testing.T, b bool, wrongField bool) {
var (
custom = stablePrimitives{FieldC: b}
transport = test.Primitives{FieldC: b}
)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Equal(t, b, result.FieldC)
} else {
require.False(t, false, result.FieldC)
}
}
func testInt32Marshal(t *testing.T, n int32, wrongField bool) {
var (
custom = stablePrimitives{FieldD: n}
transport = test.Primitives{FieldD: n}
)
result := testIntMarshal(t, custom, transport, wrongField)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Equal(t, n, result.FieldD)
@ -388,7 +526,7 @@ func testUInt32Marshal(t *testing.T, n uint32, wrongField bool) {
transport = test.Primitives{FieldE: n}
)
result := testIntMarshal(t, custom, transport, wrongField)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Equal(t, n, result.FieldE)
@ -403,7 +541,7 @@ func testInt64Marshal(t *testing.T, n int64, wrongField bool) {
transport = test.Primitives{FieldF: n}
)
result := testIntMarshal(t, custom, transport, wrongField)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Equal(t, n, result.FieldF)
@ -418,7 +556,7 @@ func testUInt64Marshal(t *testing.T, n uint64, wrongField bool) {
transport = test.Primitives{FieldG: n}
)
result := testIntMarshal(t, custom, transport, wrongField)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Equal(t, n, result.FieldG)
@ -429,17 +567,28 @@ func testUInt64Marshal(t *testing.T, n uint64, wrongField bool) {
func testEnumMarshal(t *testing.T, e SomeEnum, wrongField bool) {
var (
wire []byte
err error
custom = stablePrimitives{FieldH: e}
transport = test.Primitives{FieldH: test.Primitives_SomeEnum(e)}
)
wire, err = custom.stableMarshal(nil, wrongField)
result := testMarshal(t, custom, transport, wrongField)
if !wrongField {
require.EqualValues(t, custom.FieldH, result.FieldH)
} else {
require.EqualValues(t, 0, result.FieldH)
}
}
func testRepMarshal(t *testing.T, c stableRepPrimitives, tr test.RepPrimitives, wrongField bool) *test.RepPrimitives {
var (
wire []byte
err error
)
wire, err = c.stableMarshal(nil, wrongField)
require.NoError(t, err)
wireGen, err := transport.Marshal()
wireGen, err := tr.Marshal()
require.NoError(t, err)
if !wrongField {
@ -449,13 +598,117 @@ func testEnumMarshal(t *testing.T, e SomeEnum, wrongField bool) {
require.NotEqual(t, wireGen, wire)
}
result := new(test.Primitives)
result := new(test.RepPrimitives)
err = result.Unmarshal(wire)
require.NoError(t, err)
return result
}
func testRepeatedBytesMarshal(t *testing.T, data [][]byte, wrongField bool) {
var (
custom = stableRepPrimitives{FieldA: data}
transport = test.RepPrimitives{FieldA: data}
)
result := testRepMarshal(t, custom, transport, wrongField)
if !wrongField {
require.EqualValues(t, custom.FieldH, result.FieldH)
require.Len(t, result.FieldA, len(data))
if len(data) > 0 {
require.Equal(t, data, result.FieldA)
}
} else {
require.EqualValues(t, 0, result.FieldH)
require.Len(t, result.FieldA, 0)
}
}
func testRepeatedStringMarshal(t *testing.T, s []string, wrongField bool) {
var (
custom = stableRepPrimitives{FieldB: s}
transport = test.RepPrimitives{FieldB: s}
)
result := testRepMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldB, len(s))
if len(s) > 0 {
require.Equal(t, s, result.FieldB)
}
} else {
require.Len(t, result.FieldB, 0)
}
}
func testRepeatedInt32Marshal(t *testing.T, n []int32, wrongField bool) {
var (
custom = stableRepPrimitives{FieldC: n}
transport = test.RepPrimitives{FieldC: n}
)
result := testRepMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldC, len(n))
if len(n) > 0 {
require.Equal(t, n, result.FieldC)
}
} else {
require.Len(t, result.FieldC, 0)
}
}
func testRepeatedUInt32Marshal(t *testing.T, n []uint32, wrongField bool) {
var (
custom = stableRepPrimitives{FieldD: n}
transport = test.RepPrimitives{FieldD: n}
)
result := testRepMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldD, len(n))
if len(n) > 0 {
require.Equal(t, n, result.FieldD)
}
} else {
require.Len(t, result.FieldD, 0)
}
}
func testRepeatedInt64Marshal(t *testing.T, n []int64, wrongField bool) {
var (
custom = stableRepPrimitives{FieldE: n}
transport = test.RepPrimitives{FieldE: n}
)
result := testRepMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldE, len(n))
if len(n) > 0 {
require.Equal(t, n, result.FieldE)
}
} else {
require.Len(t, result.FieldE, 0)
}
}
func testRepeatedUInt64Marshal(t *testing.T, n []uint64, wrongField bool) {
var (
custom = stableRepPrimitives{FieldF: n}
transport = test.RepPrimitives{FieldF: n}
)
result := testRepMarshal(t, custom, transport, wrongField)
if !wrongField {
require.Len(t, result.FieldF, len(n))
if len(n) > 0 {
require.Equal(t, n, result.FieldF)
}
} else {
require.Len(t, result.FieldF, 0)
}
}

693
util/proto/test/test.pb.go
View file

@ -153,15 +153,103 @@ func (m *Primitives) GetFieldH() Primitives_SomeEnum {
return Primitives_UNKNOWN
}
type RepPrimitives struct {
FieldA [][]byte `protobuf:"bytes,1,rep,name=field_a,json=fieldA,proto3" json:"field_a,omitempty"`
FieldB []string `protobuf:"bytes,2,rep,name=field_b,json=fieldB,proto3" json:"field_b,omitempty"`
FieldC []int32 `protobuf:"varint,3,rep,packed,name=field_c,json=fieldC,proto3" json:"field_c,omitempty"`
FieldD []uint32 `protobuf:"varint,4,rep,packed,name=field_d,json=fieldD,proto3" json:"field_d,omitempty"`
FieldE []int64 `protobuf:"varint,5,rep,packed,name=field_e,json=fieldE,proto3" json:"field_e,omitempty"`
FieldF []uint64 `protobuf:"varint,6,rep,packed,name=field_f,json=fieldF,proto3" json:"field_f,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RepPrimitives) Reset() { *m = RepPrimitives{} }
func (m *RepPrimitives) String() string { return proto.CompactTextString(m) }
func (*RepPrimitives) ProtoMessage() {}
func (*RepPrimitives) Descriptor() ([]byte, []int) {
return fileDescriptor_998ad0e1a3de8558, []int{1}
}
func (m *RepPrimitives) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *RepPrimitives) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_RepPrimitives.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *RepPrimitives) XXX_Merge(src proto.Message) {
xxx_messageInfo_RepPrimitives.Merge(m, src)
}
func (m *RepPrimitives) XXX_Size() int {
return m.Size()
}
func (m *RepPrimitives) XXX_DiscardUnknown() {
xxx_messageInfo_RepPrimitives.DiscardUnknown(m)
}
var xxx_messageInfo_RepPrimitives proto.InternalMessageInfo
func (m *RepPrimitives) GetFieldA() [][]byte {
if m != nil {
return m.FieldA
}
return nil
}
func (m *RepPrimitives) GetFieldB() []string {
if m != nil {
return m.FieldB
}
return nil
}
func (m *RepPrimitives) GetFieldC() []int32 {
if m != nil {
return m.FieldC
}
return nil
}
func (m *RepPrimitives) GetFieldD() []uint32 {
if m != nil {
return m.FieldD
}
return nil
}
func (m *RepPrimitives) GetFieldE() []int64 {
if m != nil {
return m.FieldE
}
return nil
}
func (m *RepPrimitives) GetFieldF() []uint64 {
if m != nil {
return m.FieldF
}
return nil
}
func init() {
proto.RegisterEnum("test.Primitives_SomeEnum", Primitives_SomeEnum_name, Primitives_SomeEnum_value)
proto.RegisterType((*Primitives)(nil), "test.Primitives")
proto.RegisterType((*RepPrimitives)(nil), "test.RepPrimitives")
}
func init() { proto.RegisterFile("util/proto/test/test.proto", fileDescriptor_998ad0e1a3de8558) }
var fileDescriptor_998ad0e1a3de8558 = []byte{
// 254 bytes of a gzipped FileDescriptorProto
// 312 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2a, 0x2d, 0xc9, 0xcc,
0xd1, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, 0x2f, 0x49, 0x2d, 0x2e, 0x01, 0x13, 0x7a, 0x60, 0xbe,
0x10, 0x0b, 0x88, 0xad, 0xb4, 0x99, 0x89, 0x8b, 0x2b, 0xa0, 0x28, 0x33, 0x37, 0xb3, 0x24, 0xb3,
@ -175,9 +263,13 @@ var fileDescriptor_998ad0e1a3de8558 = []byte{
0x7e, 0x6e, 0xaa, 0x6b, 0x5e, 0x69, 0x2e, 0x54, 0x93, 0x87, 0x92, 0x0d, 0x17, 0x07, 0x4c, 0x4c,
0x88, 0x9b, 0x8b, 0x3d, 0xd4, 0xcf, 0xdb, 0xcf, 0x3f, 0xdc, 0x4f, 0x80, 0x41, 0x88, 0x87, 0x8b,
0x23, 0xc0, 0x3f, 0xd8, 0x33, 0xc4, 0x33, 0xcc, 0x55, 0x80, 0x51, 0x48, 0x94, 0x8b, 0xc3, 0xcf,
0xd5, 0xdd, 0x11, 0xcc, 0xfb, 0x0f, 0x03, 0x8c, 0x4e, 0x02, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78,
0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x49, 0x6c, 0xe0, 0x40, 0x35,
0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x10, 0xfa, 0xa0, 0xf4, 0x72, 0x01, 0x00, 0x00,
0xd5, 0xdd, 0x11, 0xcc, 0xfb, 0x0f, 0x03, 0x8c, 0x4a, 0x4b, 0x19, 0xb9, 0x78, 0x83, 0x52, 0x0b,
0x70, 0x05, 0x1c, 0x33, 0xae, 0x80, 0x63, 0x46, 0x0a, 0x38, 0x71, 0x44, 0xc0, 0x31, 0x2b, 0x30,
0xc3, 0x43, 0xc7, 0x19, 0x21, 0x91, 0x22, 0xc1, 0xa2, 0xc0, 0x0c, 0x0f, 0x1c, 0x17, 0x84, 0x44,
0xaa, 0x04, 0xab, 0x02, 0x33, 0x3c, 0x6c, 0x5c, 0x11, 0x12, 0x69, 0x12, 0x6c, 0x0a, 0xcc, 0xf0,
0xa0, 0x71, 0x73, 0x12, 0x38, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4,
0x18, 0x67, 0x3c, 0x96, 0x63, 0x48, 0x62, 0x03, 0x47, 0xbe, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff,
0x56, 0x51, 0xcb, 0xb3, 0x1a, 0x02, 0x00, 0x00,
}
func (m *Primitives) Marshal() (dAtA []byte, err error) {
@ -268,6 +360,125 @@ func (m *Primitives) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *RepPrimitives) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *RepPrimitives) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *RepPrimitives) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.FieldF) > 0 {
dAtA2 := make([]byte, len(m.FieldF)*10)
var j1 int
for _, num := range m.FieldF {
for num >= 1<<7 {
dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j1++
}
dAtA2[j1] = uint8(num)
j1++
}
i -= j1
copy(dAtA[i:], dAtA2[:j1])
i = encodeVarintTest(dAtA, i, uint64(j1))
i--
dAtA[i] = 0x32
}
if len(m.FieldE) > 0 {
dAtA4 := make([]byte, len(m.FieldE)*10)
var j3 int
for _, num1 := range m.FieldE {
num := uint64(num1)
for num >= 1<<7 {
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j3++
}
dAtA4[j3] = uint8(num)
j3++
}
i -= j3
copy(dAtA[i:], dAtA4[:j3])
i = encodeVarintTest(dAtA, i, uint64(j3))
i--
dAtA[i] = 0x2a
}
if len(m.FieldD) > 0 {
dAtA6 := make([]byte, len(m.FieldD)*10)
var j5 int
for _, num := range m.FieldD {
for num >= 1<<7 {
dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j5++
}
dAtA6[j5] = uint8(num)
j5++
}
i -= j5
copy(dAtA[i:], dAtA6[:j5])
i = encodeVarintTest(dAtA, i, uint64(j5))
i--
dAtA[i] = 0x22
}
if len(m.FieldC) > 0 {
dAtA8 := make([]byte, len(m.FieldC)*10)
var j7 int
for _, num1 := range m.FieldC {
num := uint64(num1)
for num >= 1<<7 {
dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j7++
}
dAtA8[j7] = uint8(num)
j7++
}
i -= j7
copy(dAtA[i:], dAtA8[:j7])
i = encodeVarintTest(dAtA, i, uint64(j7))
i--
dAtA[i] = 0x1a
}
if len(m.FieldB) > 0 {
for iNdEx := len(m.FieldB) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.FieldB[iNdEx])
copy(dAtA[i:], m.FieldB[iNdEx])
i = encodeVarintTest(dAtA, i, uint64(len(m.FieldB[iNdEx])))
i--
dAtA[i] = 0x12
}
}
if len(m.FieldA) > 0 {
for iNdEx := len(m.FieldA) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.FieldA[iNdEx])
copy(dAtA[i:], m.FieldA[iNdEx])
i = encodeVarintTest(dAtA, i, uint64(len(m.FieldA[iNdEx])))
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func encodeVarintTest(dAtA []byte, offset int, v uint64) int {
offset -= sovTest(v)
base := offset
@ -317,6 +528,58 @@ func (m *Primitives) Size() (n int) {
return n
}
func (m *RepPrimitives) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.FieldA) > 0 {
for _, b := range m.FieldA {
l = len(b)
n += 1 + l + sovTest(uint64(l))
}
}
if len(m.FieldB) > 0 {
for _, s := range m.FieldB {
l = len(s)
n += 1 + l + sovTest(uint64(l))
}
}
if len(m.FieldC) > 0 {
l = 0
for _, e := range m.FieldC {
l += sovTest(uint64(e))
}
n += 1 + sovTest(uint64(l)) + l
}
if len(m.FieldD) > 0 {
l = 0
for _, e := range m.FieldD {
l += sovTest(uint64(e))
}
n += 1 + sovTest(uint64(l)) + l
}
if len(m.FieldE) > 0 {
l = 0
for _, e := range m.FieldE {
l += sovTest(uint64(e))
}
n += 1 + sovTest(uint64(l)) + l
}
if len(m.FieldF) > 0 {
l = 0
for _, e := range m.FieldF {
l += sovTest(uint64(e))
}
n += 1 + sovTest(uint64(l)) + l
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovTest(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -558,6 +821,428 @@ func (m *Primitives) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *RepPrimitives) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: RepPrimitives: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RepPrimitives: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.FieldA = append(m.FieldA, make([]byte, postIndex-iNdEx))
copy(m.FieldA[len(m.FieldA)-1], dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.FieldB = append(m.FieldB, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 3:
if wireType == 0 {
var v int32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldC = append(m.FieldC, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
var count int
for _, integer := range dAtA[iNdEx:postIndex] {
if integer < 128 {
count++
}
}
elementCount = count
if elementCount != 0 && len(m.FieldC) == 0 {
m.FieldC = make([]int32, 0, elementCount)
}
for iNdEx < postIndex {
var v int32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldC = append(m.FieldC, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType)
}
case 4:
if wireType == 0 {
var v uint32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldD = append(m.FieldD, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
var count int
for _, integer := range dAtA[iNdEx:postIndex] {
if integer < 128 {
count++
}
}
elementCount = count
if elementCount != 0 && len(m.FieldD) == 0 {
m.FieldD = make([]uint32, 0, elementCount)
}
for iNdEx < postIndex {
var v uint32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldD = append(m.FieldD, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType)
}
case 5:
if wireType == 0 {
var v int64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldE = append(m.FieldE, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
var count int
for _, integer := range dAtA[iNdEx:postIndex] {
if integer < 128 {
count++
}
}
elementCount = count
if elementCount != 0 && len(m.FieldE) == 0 {
m.FieldE = make([]int64, 0, elementCount)
}
for iNdEx < postIndex {
var v int64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldE = append(m.FieldE, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType)
}
case 6:
if wireType == 0 {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldF = append(m.FieldF, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
var count int
for _, integer := range dAtA[iNdEx:postIndex] {
if integer < 128 {
count++
}
}
elementCount = count
if elementCount != 0 && len(m.FieldF) == 0 {
m.FieldF = make([]uint64, 0, elementCount)
}
for iNdEx < postIndex {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FieldF = append(m.FieldF, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType)
}
default:
iNdEx = preIndex
skippy, err := skipTest(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTest
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTest
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipTest(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

9
util/proto/test/test.proto
View file

@ -17,4 +17,13 @@ message Primitives {
NEGATIVE = -1;
}
SomeEnum field_h = 300;
}
message RepPrimitives {
repeated bytes field_a = 1;
repeated string field_b = 2;
repeated int32 field_c = 3;
repeated uint32 field_d = 4;
repeated int64 field_e = 5;
repeated uint64 field_f = 6;
}