From 19755fbb145dc45a41dbda7a88f202de9ab40343 Mon Sep 17 00:00:00 2001
From: Jon Steinich <jons@perblue.com>
Date: Fri, 31 Mar 2023 14:10:49 -0500
Subject: [PATCH 1/5] Add copiers for non-IMessage protobuf types

---
 .../ByteStringCopier.cs                       | 20 +++++++
 .../MapFieldCopier.cs                         | 59 +++++++++++++++++++
 .../RepeatedFieldCopier.cs                    | 55 +++++++++++++++++
 3 files changed, 134 insertions(+)
 create mode 100644 src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs
 create mode 100644 src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs
 create mode 100644 src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCopier.cs

diff --git a/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs b/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs
new file mode 100644
index 0000000000..449c1025f3
--- /dev/null
+++ b/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs
@@ -0,0 +1,20 @@
+using Google.Protobuf;
+using Orleans.Serialization.Cloning;
+
+namespace Orleans.Serialization;
+
+[RegisterCopier]
+public sealed class ByteStringCopier : IDeepCopier<ByteString>
+{
+    public ByteString DeepCopy(ByteString input, CopyContext context)
+    {
+        if (context.TryGetCopy<ByteString>(input, out var result))
+        {
+            return result;
+        }
+
+        result = ByteString.CopyFrom(input.Span);
+        context.RecordCopy(input, result);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs b/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs
new file mode 100644
index 0000000000..ca86497f37
--- /dev/null
+++ b/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs
@@ -0,0 +1,59 @@
+using Google.Protobuf.Collections;
+using Orleans.Serialization.Cloning;
+
+namespace Orleans.Serialization;
+
+/// <summary>
+/// Copier for <see cref="MapFieldCopier{TKey, TValue}"/>.
+/// </summary>
+/// <typeparam name="TKey">The type of the t key.</typeparam>
+/// <typeparam name="TValue">The type of the t value.</typeparam>
+[RegisterCopier]
+public sealed class MapFieldCopier<TKey, TValue> : IDeepCopier<MapField<TKey, TValue>>, IBaseCopier<MapField<TKey, TValue>>
+{
+    private readonly IDeepCopier<TKey> _keyCopier;
+    private readonly IDeepCopier<TValue> _valueCopier;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MapFieldCopier{TKey, TValue}"/> class.
+    /// </summary>
+    /// <param name="keyCopier">The key copier.</param>
+    /// <param name="valueCopier">The value copier.</param>
+    public MapFieldCopier(IDeepCopier<TKey> keyCopier, IDeepCopier<TValue> valueCopier)
+    {
+        _keyCopier = keyCopier;
+        _valueCopier = valueCopier;
+    }
+
+    /// <inheritdoc/>
+    public MapField<TKey, TValue> DeepCopy(MapField<TKey, TValue> input, CopyContext context)
+    {
+        if (context.TryGetCopy<MapField<TKey, TValue>>(input, out var result))
+        {
+            return result;
+        }
+
+        if (input.GetType() != typeof(MapField<TKey, TValue>))
+        {
+            return context.DeepCopy(input);
+        }
+
+        result = new MapField<TKey, TValue>();
+        context.RecordCopy(input, result);
+        foreach (var pair in input)
+        {
+            result[_keyCopier.DeepCopy(pair.Key, context)] = _valueCopier.DeepCopy(pair.Value, context);
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public void DeepCopy(MapField<TKey, TValue> input, MapField<TKey, TValue> output, CopyContext context)
+    {
+        foreach (var pair in input)
+        {
+            output[_keyCopier.DeepCopy(pair.Key, context)] = _valueCopier.DeepCopy(pair.Value, context);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCopier.cs b/src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCopier.cs
new file mode 100644
index 0000000000..61aae9ea8e
--- /dev/null
+++ b/src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCopier.cs
@@ -0,0 +1,55 @@
+using Google.Protobuf.Collections;
+using Orleans.Serialization.Cloning;
+
+namespace Orleans.Serialization;
+
+/// <summary>
+/// Copier for <see cref="RepeatedField{T}"/>.
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+[RegisterCopier]
+public sealed class RepeatedFieldCopier<T> : IDeepCopier<RepeatedField<T>>, IBaseCopier<RepeatedField<T>>
+{
+    private readonly IDeepCopier<T> _copier;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RepeatedFieldCopier{T}"/> class.
+    /// </summary>
+    /// <param name="valueCopier">The value copier.</param>
+    public RepeatedFieldCopier(IDeepCopier<T> valueCopier)
+    {
+        _copier = valueCopier;
+    }
+
+    /// <inheritdoc/>
+    public RepeatedField<T> DeepCopy(RepeatedField<T> input, CopyContext context)
+    {
+        if (context.TryGetCopy<RepeatedField<T>>(input, out var result))
+        {
+            return result;
+        }
+
+        if (input.GetType() != typeof(RepeatedField<T>))
+        {
+            return context.DeepCopy(input);
+        }
+
+        result = new RepeatedField<T> { Capacity = input.Count };
+        context.RecordCopy(input, result);
+        foreach (var item in input)
+        {
+            result.Add(_copier.DeepCopy(item, context));
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public void DeepCopy(RepeatedField<T> input, RepeatedField<T> output, CopyContext context)
+    {
+        foreach (var item in input)
+        {
+            output.Add(_copier.DeepCopy(item, context));
+        }
+    }
+}
\ No newline at end of file

From af50c6cab3a69283ba1f5ff206fcf6d48d8e6881 Mon Sep 17 00:00:00 2001
From: Jon Steinich <jons@perblue.com>
Date: Fri, 31 Mar 2023 14:48:42 -0500
Subject: [PATCH 2/5] add tests

---
 .../ProtobufSerializerTests.cs                | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs b/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs
index 0ae491fdba..54636cc8cb 100644
--- a/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs
+++ b/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs
@@ -1,6 +1,8 @@
 #nullable enable
 using System;
+using System.Linq;
 using Google.Protobuf;
+using Google.Protobuf.Collections;
 using Microsoft.Extensions.DependencyInjection;
 using Orleans.Serialization.Cloning;
 using Orleans.Serialization.Codecs;
@@ -101,6 +103,71 @@ protected override void Configure(ISerializerBuilder builder)
     };
 }
 
+[Trait("Category", "BVT")]
+public class ProtobufRepeatedFieldCopierTests : CopierTester<RepeatedField<int>, IDeepCopier<RepeatedField<int>>>
+{
+    public ProtobufRepeatedFieldCopierTests(ITestOutputHelper output) : base(output)
+    {
+    }
+
+    protected override IDeepCopier<RepeatedField<int>> CreateCopier() => ServiceProvider.GetRequiredService<ICodecProvider>().GetDeepCopier<RepeatedField<int>>();
+
+    protected override RepeatedField<int> CreateValue()
+    {
+        var result = new RepeatedField<int>();
+        for (var i = 0; i < Random.Next(17) + 5; i++)
+        {
+            result.Add(Random.Next());
+        }
+
+        return result;
+    }
+
+    protected override bool Equals(RepeatedField<int> left, RepeatedField<int> right) => object.ReferenceEquals(left, right) || left.SequenceEqual(right);
+    protected override RepeatedField<int>[] TestValues => new[] { new RepeatedField<int>(), CreateValue(), CreateValue(), CreateValue() };
+}
+
+[Trait("Category", "BVT")]
+public class MapFieldCopierTests : CopierTester<MapField<string, int>, MapFieldCopier<string, int>>
+{
+    public MapFieldCopierTests(ITestOutputHelper output) : base(output)
+    {
+    }
+
+    protected override MapField<string, int> CreateValue()
+    {
+        var result = new MapField<string, int>();
+        for (var i = 0; i < Random.Next(17) + 5; i++)
+        {
+            result[Random.Next().ToString()] = Random.Next();
+        }
+
+        return result;
+    }
+
+    protected override MapField<string, int>[] TestValues => new[] { new MapField<string, int>(), CreateValue(), CreateValue(), CreateValue() };
+    protected override bool Equals(MapField<string, int> left, MapField<string, int> right) => object.ReferenceEquals(left, right) || left.SequenceEqual(right);
+}
+
+[Trait("Category", "BVT")]
+public class ByteStringCopierTests : CopierTester<ByteString, ByteStringCopier>
+{
+    public ByteStringCopierTests(ITestOutputHelper output) : base(output)
+    {
+    }
+
+    protected override ByteString CreateValue() => Guid.NewGuid().ToByteString();
+
+    protected override bool Equals(ByteString left, ByteString right) => ReferenceEquals(left, right) || left.SequenceEqual(right);
+
+    protected override ByteString[] TestValues => new[]
+    {
+        ByteString.Empty,
+        ByteString.CopyFrom(Enumerable.Range(0, 4097).Select(b => unchecked((byte)b)).ToArray()),
+        CreateValue()
+    };
+}
+
 public static class ProtobufGuidExtensions
 {
     public static ByteString ToByteString(this Guid guid)

From 90c9743260c16e008f80b2a69506c6540531283e Mon Sep 17 00:00:00 2001
From: Jon Steinich <jons@perblue.com>
Date: Fri, 31 Mar 2023 15:38:00 -0500
Subject: [PATCH 3/5] Some code doc cleanup

---
 .../Orleans.Serialization.Protobuf/ByteStringCopier.cs        | 4 ++++
 .../Orleans.Serialization.Protobuf/MapFieldCopier.cs          | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs b/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs
index 449c1025f3..3f96ea306b 100644
--- a/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs
+++ b/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCopier.cs
@@ -3,9 +3,13 @@
 
 namespace Orleans.Serialization;
 
+/// <summary>
+/// Copier for <see cref="ByteString"/>.
+/// </summary>
 [RegisterCopier]
 public sealed class ByteStringCopier : IDeepCopier<ByteString>
 {
+    /// <inheritdoc/>
     public ByteString DeepCopy(ByteString input, CopyContext context)
     {
         if (context.TryGetCopy<ByteString>(input, out var result))
diff --git a/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs b/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs
index ca86497f37..9d1093a885 100644
--- a/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs
+++ b/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCopier.cs
@@ -4,7 +4,7 @@
 namespace Orleans.Serialization;
 
 /// <summary>
-/// Copier for <see cref="MapFieldCopier{TKey, TValue}"/>.
+/// Copier for <see cref="MapField{TKey, TValue}"/>.
 /// </summary>
 /// <typeparam name="TKey">The type of the t key.</typeparam>
 /// <typeparam name="TValue">The type of the t value.</typeparam>

From 650862c5767b1dd429355c2f6da31524f3e00c05 Mon Sep 17 00:00:00 2001
From: Jon Steinich <jons@perblue.com>
Date: Mon, 3 Apr 2023 15:21:06 -0500
Subject: [PATCH 4/5] Add codecs as well

---
 .../ByteStringCodec.cs                        |  42 ++++++
 .../MapFieldCodec.cs                          | 135 ++++++++++++++++++
 .../RepeatedFieldCodec.cs                     | 118 +++++++++++++++
 3 files changed, 295 insertions(+)
 create mode 100644 src/Serializers/Orleans.Serialization.Protobuf/ByteStringCodec.cs
 create mode 100644 src/Serializers/Orleans.Serialization.Protobuf/MapFieldCodec.cs
 create mode 100644 src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCodec.cs

diff --git a/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCodec.cs b/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCodec.cs
new file mode 100644
index 0000000000..561ae06bcf
--- /dev/null
+++ b/src/Serializers/Orleans.Serialization.Protobuf/ByteStringCodec.cs
@@ -0,0 +1,42 @@
+using System;
+using Google.Protobuf;
+using Orleans.Serialization.Buffers;
+using Orleans.Serialization.Codecs;
+using Orleans.Serialization.WireProtocol;
+
+namespace Orleans.Serialization;
+
+/// <summary>
+/// Serializer for <see cref="ByteString"/>.
+/// </summary>
+[RegisterSerializer]
+public sealed class ByteStringCodec : IFieldCodec<ByteString>
+{
+    /// <inheritdoc/>
+    ByteString IFieldCodec<ByteString>.ReadValue<TInput>(ref Reader<TInput> reader, Field field)
+    {
+        if (field.WireType == WireType.Reference)
+        {
+            return ReferenceCodec.ReadReference<ByteString, TInput>(ref reader, field);
+        }
+
+        field.EnsureWireType(WireType.LengthPrefixed);
+        var length = reader.ReadVarUInt32();
+        var result = UnsafeByteOperations.UnsafeWrap(reader.ReadBytes(length));
+        ReferenceCodec.RecordObject(reader.Session, result);
+        return result;
+    }
+
+    /// <inheritdoc/>
+    void IFieldCodec<ByteString>.WriteField<TBufferWriter>(ref Writer<TBufferWriter> writer, uint fieldIdDelta, Type expectedType, ByteString value)
+    {
+        if (ReferenceCodec.TryWriteReferenceField(ref writer, fieldIdDelta, expectedType, value))
+        {
+            return;
+        }
+
+        writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(ByteString), WireType.LengthPrefixed);
+        writer.WriteVarUInt32((uint)value.Length);
+        writer.Write(value.Span);
+    }
+}
\ No newline at end of file
diff --git a/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCodec.cs b/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCodec.cs
new file mode 100644
index 0000000000..5ca1fe953a
--- /dev/null
+++ b/src/Serializers/Orleans.Serialization.Protobuf/MapFieldCodec.cs
@@ -0,0 +1,135 @@
+using System;
+using System.Buffers;
+using Google.Protobuf.Collections;
+using Orleans.Serialization.Buffers;
+using Orleans.Serialization.Codecs;
+using Orleans.Serialization.GeneratedCodeHelpers;
+using Orleans.Serialization.Session;
+using Orleans.Serialization.WireProtocol;
+
+namespace Orleans.Serialization;
+
+/// <summary>
+/// Serializer for <see cref="MapField{TKey,TValue}"/>.
+/// </summary>
+/// <typeparam name="TKey">The key type.</typeparam>
+/// <typeparam name="TValue">The value type.</typeparam>
+[RegisterSerializer]
+public sealed class MapFieldCodec<TKey, TValue> : IFieldCodec<MapField<TKey, TValue>>
+{
+    private readonly Type _keyFieldType = typeof(TKey);
+    private readonly Type _valueFieldType = typeof(TValue);
+
+    private readonly IFieldCodec<TKey> _keyCodec;
+    private readonly IFieldCodec<TValue> _valueCodec;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MapFieldCodec{TKey, TValue}"/> class.
+    /// </summary>
+    /// <param name="keyCodec">The key codec.</param>
+    /// <param name="valueCodec">The value codec.</param>
+    public MapFieldCodec(
+        IFieldCodec<TKey> keyCodec,
+        IFieldCodec<TValue> valueCodec)
+    {
+        _keyCodec = OrleansGeneratedCodeHelper.UnwrapService(this, keyCodec);
+        _valueCodec = OrleansGeneratedCodeHelper.UnwrapService(this, valueCodec);
+    }
+
+    /// <inheritdoc/>
+    public void WriteField<TBufferWriter>(ref Writer<TBufferWriter> writer, uint fieldIdDelta, Type expectedType, MapField<TKey, TValue> value) where TBufferWriter : IBufferWriter<byte>
+    {
+        if (ReferenceCodec.TryWriteReferenceField(ref writer, fieldIdDelta, expectedType, value))
+        {
+            return;
+        }
+
+        writer.WriteFieldHeader(fieldIdDelta, expectedType, value.GetType(), WireType.TagDelimited);
+
+        if (value.Count > 0)
+        {
+            UInt32Codec.WriteField(ref writer, 0, (uint)value.Count);
+            uint innerFieldIdDelta = 1;
+            foreach (var element in value)
+            {
+                _keyCodec.WriteField(ref writer, innerFieldIdDelta, _keyFieldType, element.Key);
+                _valueCodec.WriteField(ref writer, 0, _valueFieldType, element.Value);
+                innerFieldIdDelta = 0;
+            }
+        }
+
+        writer.WriteEndObject();
+    }
+
+    /// <inheritdoc/>
+    public MapField<TKey, TValue> ReadValue<TInput>(ref Reader<TInput> reader, Field field)
+    {
+        if (field.WireType == WireType.Reference)
+        {
+            return ReferenceCodec.ReadReference<MapField<TKey, TValue>, TInput>(ref reader, field);
+        }
+
+        field.EnsureWireTypeTagDelimited();
+
+        var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
+        TKey key = default;
+        var valueExpected = false;
+        MapField<TKey, TValue> result = null;
+        uint fieldId = 0;
+        while (true)
+        {
+            var header = reader.ReadFieldHeader();
+            if (header.IsEndBaseOrEndObject)
+            {
+                break;
+            }
+
+            fieldId += header.FieldIdDelta;
+            switch (fieldId)
+            {
+                case 0:
+                    var length = (int)UInt32Codec.ReadValue(ref reader, header);
+                    if (length > 10240 && length > reader.Length)
+                    {
+                        ThrowInvalidSizeException(length);
+                    }
+
+                    result = CreateInstance(reader.Session, placeholderReferenceId);
+                    break;
+                case 1:
+                    if (result is null)
+                        ThrowLengthFieldMissing();
+
+                    if (!valueExpected)
+                    {
+                        key = _keyCodec.ReadValue(ref reader, header);
+                        valueExpected = true;
+                    }
+                    else
+                    {
+                        result.Add(key, _valueCodec.ReadValue(ref reader, header));
+                        valueExpected = false;
+                    }
+                    break;
+                default:
+                    reader.ConsumeUnknownField(header);
+                    break;
+            }
+        }
+
+        result ??= CreateInstance(reader.Session, placeholderReferenceId);
+        return result;
+    }
+
+    private static MapField<TKey, TValue> CreateInstance(SerializerSession session, uint placeholderReferenceId)
+    {
+        var result = new MapField<TKey, TValue>();
+        ReferenceCodec.RecordObject(session, result, placeholderReferenceId);
+        return result;
+    }
+
+    private static void ThrowInvalidSizeException(int length) => throw new IndexOutOfRangeException(
+        $"Declared length of {typeof(MapField<TKey, TValue>)}, {length}, is greater than total length of input.");
+
+    private static void ThrowLengthFieldMissing() => throw new RequiredFieldMissingException("Serialized MapField is missing its length field.");
+}
\ No newline at end of file
diff --git a/src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCodec.cs b/src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCodec.cs
new file mode 100644
index 0000000000..909cc8fca5
--- /dev/null
+++ b/src/Serializers/Orleans.Serialization.Protobuf/RepeatedFieldCodec.cs
@@ -0,0 +1,118 @@
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using Google.Protobuf.Collections;
+using Orleans.Serialization.Buffers;
+using Orleans.Serialization.Codecs;
+using Orleans.Serialization.GeneratedCodeHelpers;
+using Orleans.Serialization.WireProtocol;
+
+namespace Orleans.Serialization;
+
+/// <summary>
+/// Serializer for <see cref="RepeatedField{T}"/>.
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+[RegisterSerializer]
+public sealed class RepeatedFieldCodec<T> : IFieldCodec<RepeatedField<T>>
+{
+    private readonly Type CodecElementType = typeof(T);
+
+    private readonly IFieldCodec<T> _fieldCodec;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RepeatedFieldCodec{T}"/> class.
+    /// </summary>
+    /// <param name="fieldCodec">The field codec.</param>
+    public RepeatedFieldCodec(IFieldCodec<T> fieldCodec)
+    {
+        _fieldCodec = OrleansGeneratedCodeHelper.UnwrapService(this, fieldCodec);
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteField<TBufferWriter>(ref Writer<TBufferWriter> writer, uint fieldIdDelta, Type expectedType, RepeatedField<T> value) where TBufferWriter : IBufferWriter<byte>
+    {
+        if (ReferenceCodec.TryWriteReferenceField(ref writer, fieldIdDelta, expectedType, value))
+        {
+            return;
+        }
+
+        writer.WriteFieldHeader(fieldIdDelta, expectedType, value.GetType(), WireType.TagDelimited);
+
+        if (value.Count > 0)
+        {
+            UInt32Codec.WriteField(ref writer, 0, (uint)value.Count);
+            uint innerFieldIdDelta = 1;
+            foreach (var element in value)
+            {
+                _fieldCodec.WriteField(ref writer, innerFieldIdDelta, CodecElementType, element);
+                innerFieldIdDelta = 0;
+            }
+        }
+
+        writer.WriteEndObject();
+    }
+
+    /// <inheritdoc/>
+    public RepeatedField<T> ReadValue<TInput>(ref Reader<TInput> reader, Field field)
+    {
+        if (field.WireType == WireType.Reference)
+        {
+            return ReferenceCodec.ReadReference<RepeatedField<T>, TInput>(ref reader, field);
+        }
+
+        field.EnsureWireTypeTagDelimited();
+
+        var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
+        RepeatedField<T> result = null;
+        uint fieldId = 0;
+        while (true)
+        {
+            var header = reader.ReadFieldHeader();
+            if (header.IsEndBaseOrEndObject)
+            {
+                break;
+            }
+
+            fieldId += header.FieldIdDelta;
+            switch (fieldId)
+            {
+                case 0:
+                    var length = (int)UInt32Codec.ReadValue(ref reader, header);
+                    if (length > 10240 && length > reader.Length)
+                    {
+                        ThrowInvalidSizeException(length);
+                    }
+
+                    result = new RepeatedField<T>{ Capacity = length };
+                    ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
+                    break;
+                case 1:
+                    if (result is null)
+                    {
+                        ThrowLengthFieldMissing();
+                    }
+
+                    result.Add(_fieldCodec.ReadValue(ref reader, header));
+                    break;
+                default:
+                    reader.ConsumeUnknownField(header);
+                    break;
+            }
+        }
+
+        if (result is null)
+        {
+            result = new();
+            ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
+        }
+
+        return result;
+    }
+
+    private static void ThrowInvalidSizeException(int length) => throw new IndexOutOfRangeException(
+        $"Declared length of {typeof(RepeatedField<T>)}, {length}, is greater than total length of input.");
+
+    private static void ThrowLengthFieldMissing() => throw new RequiredFieldMissingException("Serialized RepeatedField is missing its length field.");
+}
\ No newline at end of file

From f59f00d2eac51693b7ead8190b1894497d211efb Mon Sep 17 00:00:00 2001
From: Jon Steinich <jons@perblue.com>
Date: Mon, 3 Apr 2023 15:28:13 -0500
Subject: [PATCH 5/5] add codec tests

---
 .../ProtobufSerializerTests.cs                | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs b/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs
index 54636cc8cb..5ff46c04e8 100644
--- a/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs
+++ b/test/Orleans.Serialization.UnitTests/ProtobufSerializerTests.cs
@@ -103,6 +103,28 @@ protected override void Configure(ISerializerBuilder builder)
     };
 }
 
+[Trait("Category", "BVT")]
+public class ProtobufRepeatedFieldCodecTests : FieldCodecTester<RepeatedField<int>, RepeatedFieldCodec<int>>
+{
+    public ProtobufRepeatedFieldCodecTests(ITestOutputHelper output) : base(output)
+    {
+    }
+
+    protected override RepeatedField<int> CreateValue()
+    {
+        var result = new RepeatedField<int>();
+        for (var i = 0; i < Random.Next(17) + 5; i++)
+        {
+            result.Add(Random.Next());
+        }
+
+        return result;
+    }
+
+    protected override bool Equals(RepeatedField<int> left, RepeatedField<int> right) => object.ReferenceEquals(left, right) || left.SequenceEqual(right);
+    protected override RepeatedField<int>[] TestValues => new[] { new RepeatedField<int>(), CreateValue(), CreateValue(), CreateValue() };
+}
+
 [Trait("Category", "BVT")]
 public class ProtobufRepeatedFieldCopierTests : CopierTester<RepeatedField<int>, IDeepCopier<RepeatedField<int>>>
 {
@@ -127,6 +149,28 @@ protected override RepeatedField<int> CreateValue()
     protected override RepeatedField<int>[] TestValues => new[] { new RepeatedField<int>(), CreateValue(), CreateValue(), CreateValue() };
 }
 
+[Trait("Category", "BVT")]
+public class MapFieldCodecTests : FieldCodecTester<MapField<string, int>, MapFieldCodec<string, int>>
+{
+    public MapFieldCodecTests(ITestOutputHelper output) : base(output)
+    {
+    }
+
+    protected override MapField<string, int> CreateValue()
+    {
+        var result = new MapField<string, int>();
+        for (var i = 0; i < Random.Next(17) + 5; i++)
+        {
+            result[Random.Next().ToString()] = Random.Next();
+        }
+
+        return result;
+    }
+
+    protected override MapField<string, int>[] TestValues => new[] { new MapField<string, int>(), CreateValue(), CreateValue(), CreateValue() };
+    protected override bool Equals(MapField<string, int> left, MapField<string, int> right) => object.ReferenceEquals(left, right) || left.SequenceEqual(right);
+}
+
 [Trait("Category", "BVT")]
 public class MapFieldCopierTests : CopierTester<MapField<string, int>, MapFieldCopier<string, int>>
 {
@@ -149,6 +193,25 @@ protected override MapField<string, int> CreateValue()
     protected override bool Equals(MapField<string, int> left, MapField<string, int> right) => object.ReferenceEquals(left, right) || left.SequenceEqual(right);
 }
 
+[Trait("Category", "BVT")]
+public class ByteStringCodecTests : FieldCodecTester<ByteString, ByteStringCodec>
+{
+    public ByteStringCodecTests(ITestOutputHelper output) : base(output)
+    {
+    }
+
+    protected override ByteString CreateValue() => Guid.NewGuid().ToByteString();
+
+    protected override bool Equals(ByteString left, ByteString right) => ReferenceEquals(left, right) || left.SequenceEqual(right);
+
+    protected override ByteString[] TestValues => new[]
+    {
+        ByteString.Empty,
+        ByteString.CopyFrom(Enumerable.Range(0, 4097).Select(b => unchecked((byte)b)).ToArray()),
+        CreateValue()
+    };
+}
+
 [Trait("Category", "BVT")]
 public class ByteStringCopierTests : CopierTester<ByteString, ByteStringCopier>
 {