Refactor BinarySerializationProtocol

Author: CharliePoole

src/NUnitEngine/nunit.engine.core.tests/Communication/Protocols/BinarySerializationProtocolTests.cs

@@ -50,8 +50,8 @@ public void DecodeSingleMessage()
 
             Assert.That(message.Code, Is.EqualTo(MessageCode.CommandResult));
             Assert.That(message.Data, Is.EqualTo(originalPackage.ToXml()));
-            //var newPackage = DeserializePackage(message.Data);
-            //ComparePackages(newPackage, originalPackage);
+            var newPackage = new TestPackage().FromXml(message.Data);
+            ComparePackages(newPackage, originalPackage);
         }
 
         [TestCase(1)]
@@ -88,8 +88,8 @@ public void DecodeSplitMessages(int numMessages)
             foreach (TestEngineMessage message in messages)
             {
                 Assert.That(message.Code, Is.EqualTo(MessageCode.CommandResult));
-                //var newPackage = DeserializePackage(message.Data);
-                //ComparePackages(newPackage, originalPackage);
+                var newPackage = new TestPackage().FromXml(message.Data);
+                ComparePackages(newPackage, originalPackage);
             }
         }
 
@@ -113,5 +113,24 @@ public void DecodeMultipleMessages()
                 Assert.That(received[i].Code, Is.EqualTo(commands[i]));
         }
 
+        private void ComparePackages(TestPackage newPackage, TestPackage oldPackage)
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.That(newPackage.Name, Is.EqualTo(oldPackage.Name));
+                Assert.That(newPackage.FullName, Is.EqualTo(oldPackage.FullName));
+                Assert.That(newPackage.Settings.Count, Is.EqualTo(oldPackage.Settings.Count));
+                Assert.That(newPackage.SubPackages.Count, Is.EqualTo(oldPackage.SubPackages.Count));
+
+                foreach (var key in oldPackage.Settings.Keys)
+                {
+                    Assert.That(newPackage.Settings.ContainsKey(key));
+                    Assert.That(newPackage.Settings[key], Is.EqualTo(oldPackage.Settings[key]));
+                }
+
+                for (int i = 0; i < oldPackage.SubPackages.Count; i++)
+                    ComparePackages(newPackage.SubPackages[i], oldPackage.SubPackages[i]);
+            });
+        }
     }
 }

src/NUnitEngine/nunit.engine.core/Communication/Protocols/BinarySerializationProtocol.cs

@@ -5,20 +5,29 @@
 using System.IO;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
+using System.Text;
 using NUnit.Engine.Communication.Messages;
 
 namespace NUnit.Engine.Communication.Protocols
 {
     /// <summary>
-    /// BinarySerializationProtocol serializes messages in the following format:
+    /// BinarySerializationProtocol serializes messages as an array of bytes in the following format:
     ///
-    ///     [Message Length (4 bytes)][Serialized Message Content]
-    ///     
-    /// The message content is in binary form as produced by the .NET BinaryFormatter.
-    /// Each message of length n is serialized as n + 4 bytes.
+    ///     <Message Length> <Message Code> [<Additional Message Data>]
+    ///
+    /// The length of the message is encoded as four bytes, from lowest to highest order.
+    /// 
+    /// The message code is always four bytes and indicates the type of message.
+    /// 
+    /// Messages taking an additional data argument encode it in the remaining bytes. The
+    /// argument length may therefore be calculated as overall length - 8 bytes. Messages
+    /// without an argument are serialized as 8 bytes.
     /// </summary>
     public class BinarySerializationProtocol : ISerializationProtocol
     {
+        private const int MSG_LENGTH_SIZE = 4;
+        private const int MSG_CODE_SIZE = 4;
+
         /// <summary>
         /// Maximum length of a message.
         /// </summary>
@@ -34,24 +43,30 @@ public class BinarySerializationProtocol : ISerializationProtocol
         /// </summary>
         /// <param name="message">Message to be serialized</param>
         /// <returns>A byte[] containing the message, serialized as per the protocol.</returns>
-        public byte[] Encode(object message)
+        public byte[] Encode(TestEngineMessage message)
         {
-            //Serialize the message to a byte array
-            var serializedMessage = SerializeMessage(message);
+            string code = message.Code;
+            string data = message.Data;
+            Encoding utf8 = Encoding.UTF8;
+
+            // TODO: Compile time check
+            if (utf8.GetByteCount(code) != MSG_CODE_SIZE)
+                throw new ArgumentException($"Invalid message code {code}");
+
+            int dataLength = message.Data != null ? utf8.GetByteCount(message.Data) : 0;
+            int messageLength = dataLength + MSG_CODE_SIZE;
 
-            //Check for message length
-            var messageLength = serializedMessage.Length;
+            //Check message length
             if (messageLength > MAX_MESSAGE_LENGTH)
-            {
                 throw new Exception("Message is too big (" + messageLength + " bytes). Max allowed length is " + MAX_MESSAGE_LENGTH + " bytes.");
-            }
 
             //Create a byte array including the length of the message (4 bytes) and serialized message content
-            var bytes = new byte[messageLength + 4];
+            var bytes = new byte[messageLength + MSG_LENGTH_SIZE];
             WriteInt32(bytes, 0, messageLength);
-            Array.Copy(serializedMessage, 0, bytes, 4, messageLength);
+            utf8.GetBytes(code, 0, code.Length, bytes, MSG_LENGTH_SIZE);
+            if (dataLength > 0)
+                utf8.GetBytes(data, 0, data.Length, bytes, MSG_LENGTH_SIZE + MSG_CODE_SIZE);
 
-            //Return serialized message by this protocol
             return bytes;
         }
 
@@ -139,23 +154,21 @@ private bool ReadSingleMessage(ICollection<TestEngineMessage> messages)
 
             //If stream has less than 4 bytes, that means we can not even read length of the message
             //So, return false to wait more for bytes from remorte application.
-            if (_receiveMemoryStream.Length < 4)
+            if (_receiveMemoryStream.Length < MSG_LENGTH_SIZE)
             {
                 return false;
             }
 
             //Read length of the message
             var messageLength = ReadInt32(_receiveMemoryStream);
             if (messageLength > MAX_MESSAGE_LENGTH)
-            {
                 throw new Exception("Message is too big (" + messageLength + " bytes). Max allowed length is " + MAX_MESSAGE_LENGTH + " bytes.");
-            }
 
             //If message is zero-length (It must not be but good approach to check it)
             if (messageLength == 0)
             {
                 //if no more bytes, return immediately
-                if (_receiveMemoryStream.Length == 4)
+                if (_receiveMemoryStream.Length == MSG_LENGTH_SIZE)
                 {
                     _receiveMemoryStream = new MemoryStream(); //Clear the stream
                     return false;
@@ -164,12 +177,12 @@ private bool ReadSingleMessage(ICollection<TestEngineMessage> messages)
                 //Create a new memory stream from current except first 4-bytes.
                 var bytes = _receiveMemoryStream.ToArray();
                 _receiveMemoryStream = new MemoryStream();
-                _receiveMemoryStream.Write(bytes, 4, bytes.Length - 4);
+                _receiveMemoryStream.Write(bytes, MSG_LENGTH_SIZE, bytes.Length - MSG_LENGTH_SIZE);
                 return true;
             }
 
             //If all bytes of the message is not received yet, return to wait more bytes
-            if (_receiveMemoryStream.Length < (4 + messageLength))
+            if (_receiveMemoryStream.Length < (MSG_LENGTH_SIZE + messageLength))
             {
                 _receiveMemoryStream.Position = _receiveMemoryStream.Length;
                 return false;
@@ -178,7 +191,15 @@ private bool ReadSingleMessage(ICollection<TestEngineMessage> messages)
             //Read bytes of serialized message and deserialize it
             var serializedMessageBytes = ReadByteArray(_receiveMemoryStream, messageLength);
 
-            messages.Add((TestEngineMessage)DeserializeMessage(serializedMessageBytes));
+            Encoding utf8 = Encoding.UTF8;
+
+            string code = utf8.GetString(serializedMessageBytes, 0, MSG_CODE_SIZE);
+
+            string data = messageLength > MSG_CODE_SIZE
+                ? utf8.GetString(serializedMessageBytes, MSG_CODE_SIZE, messageLength - MSG_CODE_SIZE)
+                : null;
+
+            messages.Add(new TestEngineMessage(code, data));
 
             //Read remaining bytes to an array
             var remainingBytes = ReadByteArray(_receiveMemoryStream, (int)(_receiveMemoryStream.Length - (4 + messageLength)));
@@ -188,7 +209,7 @@ private bool ReadSingleMessage(ICollection<TestEngineMessage> messages)
             _receiveMemoryStream.Write(remainingBytes, 0, remainingBytes.Length);
 
             //Return true to re-call this method to try to read next message
-            return (remainingBytes.Length > 4);
+            return (remainingBytes.Length > MSG_LENGTH_SIZE);
         }
 
         /// <summary>
@@ -212,10 +233,15 @@ private static void WriteInt32(byte[] buffer, int startIndex, int number)
         private static int ReadInt32(Stream stream)
         {
             var buffer = ReadByteArray(stream, 4);
-            return ((buffer[0] << 24) |
-                    (buffer[1] << 16) |
-                    (buffer[2] << 8) |
-                    (buffer[3])
+            return ReadInt32(buffer, 0);
+        }
+
+        private static int ReadInt32(byte[] buffer, int index)
+        {
+            return ((buffer[index] << 24) |
+                    (buffer[index + 1] << 16) |
+                    (buffer[index + 2] << 8) |
+                    (buffer[index + 3])
                    );
         }
 

src/NUnitEngine/nunit.engine.core/Communication/Protocols/ISerializationProtocol.cs

@@ -12,7 +12,7 @@ public interface ISerializationProtocol
         /// </summary>
         /// <param name="message">Message to be serialized</param>
         /// <returns>A byte[] containing the message, serialized as per the protocol.</returns>
-        byte[] Encode(object message);
+        byte[] Encode(TestEngineMessage message);
 
         /// <summary>
         /// Accept an array of bytes and deserialize the messages that are found.