Add stable marshal helpers for repeated fields

Signed-off-by: Alex Vanin <alexey@nspcc.ru>

util/proto/marshal.go

@@ -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

util/proto/marshal_test.go

@@ -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) {
+func TestRepeatedBytesMarshal(t *testing.T) {
-	var (
+	t.Run("not empty", func(t *testing.T) {
-		wire []byte
+		data := [][]byte{[]byte("One"), []byte("Two"), []byte("Three")}
-		err  error
+		testRepeatedBytesMarshal(t, data, false)
+		testRepeatedBytesMarshal(t, data, true)
+	})
 
-		custom    = stablePrimitives{FieldA: data}
+	t.Run("empty", func(t *testing.T) {
-		transport = test.Primitives{FieldA: data}
+		testRepeatedBytesMarshal(t, [][]byte{}, false)
-	)
+	})
 
-	wire, err = custom.stableMarshal(nil, wrongField)
+	t.Run("nil", func(t *testing.T) {
-	require.NoError(t, err)
+		testRepeatedBytesMarshal(t, nil, false)
-
+	})
-	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)
-	}
 }
 
-func testStringMarshal(t *testing.T, s string, wrongField bool) {
+func TestRepeatedStringMarshal(t *testing.T) {
-	var (
+	t.Run("not empty", func(t *testing.T) {
-		wire []byte
+		data := []string{"One", "Two", "Three"}
-		err  error
+		testRepeatedStringMarshal(t, data, false)
+		testRepeatedStringMarshal(t, data, true)
+	})
 
-		custom    = stablePrimitives{FieldB: s}
+	t.Run("empty", func(t *testing.T) {
-		transport = test.Primitives{FieldB: s}
+		testRepeatedStringMarshal(t, []string{}, false)
-	)
+	})
 
-	wire, err = custom.stableMarshal(nil, wrongField)
+	t.Run("nil", func(t *testing.T) {
-	require.NoError(t, err)
+		testRepeatedStringMarshal(t, nil, false)
-
+	})
-	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)
-	}
 }
 
-func testBoolMarshal(t *testing.T, b bool, wrongField bool) {
+func TestRepeatedInt32Marshal(t *testing.T) {
-	var (
+	t.Run("not empty", func(t *testing.T) {
-		wire []byte
+		data := []int32{-1, 0, 1, 2, 3, 4, 5}
-		err  error
+		testRepeatedInt32Marshal(t, data, false)
+		testRepeatedInt32Marshal(t, data, true)
+	})
 
-		custom    = stablePrimitives{FieldC: b}
+	t.Run("empty", func(t *testing.T) {
-		transport = test.Primitives{FieldC: b}
+		testRepeatedInt32Marshal(t, []int32{}, false)
-	)
+	})
 
-	wire, err = custom.stableMarshal(nil, wrongField)
+	t.Run("nil", func(t *testing.T) {
-	require.NoError(t, err)
+		testRepeatedInt32Marshal(t, nil, false)
-
+	})
-	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)
-	}
 }
 
-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)
 	}
 }

util/proto/test/test.pb.go

@@ -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,
+	0xd5, 0xdd, 0x11, 0xcc, 0xfb, 0x0f, 0x03, 0x8c, 0x4a, 0x4b, 0x19, 0xb9, 0x78, 0x83, 0x52, 0x0b,
-	0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x49, 0x6c, 0xe0, 0x40, 0x35,
+	0x70, 0x05, 0x1c, 0x33, 0xae, 0x80, 0x63, 0x46, 0x0a, 0x38, 0x71, 0x44, 0xc0, 0x31, 0x2b, 0x30,
-	0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x10, 0xfa, 0xa0, 0xf4, 0x72, 0x01, 0x00, 0x00,
+	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

util/proto/test/test.proto

@@ -18,3 +18,12 @@ message Primitives {
     }
     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;
+}