Added unit tests for `InsertMessage()` and fixed some issues brought to light by...

diff --git a/Hazel.UnitTests/MessageReaderTests.cs b/Hazel.UnitTests/MessageReaderTests.cs
index ef4c20838f55239b2e5fee45b349f7741031aa21..4939fad083d2910070c974e17a69f1dcba049bd6 100644 (file)
--- a/Hazel.UnitTests/MessageReaderTests.cs
+++ b/Hazel.UnitTests/MessageReaderTests.cs
@@ -145,6 +145,267 @@ namespace Hazel.UnitTests
             Assert.AreEqual(Test5, five.ReadByte());
         }
 
+        [TestMethod]
+        public void InsertMessageWorks()
+        {
+            const byte Test0 = 11;
+            const byte Test3 = 33;
+            const byte Test4 = 44;
+            const byte Test5 = 55;
+            const byte TestInsert = 66;
+
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(0);
+            msg.Write(Test0);
+            msg.EndMessage();
+
+            msg.StartMessage(12);
+            msg.StartMessage(23);
+
+            msg.StartMessage(34);
+            msg.Write(Test3);
+            msg.EndMessage();
+
+            msg.StartMessage(45);
+            msg.Write(Test4);
+            msg.EndMessage();
+
+            msg.EndMessage();
+            msg.EndMessage();
+
+            msg.StartMessage(56);
+            msg.Write(Test5);
+            msg.EndMessage();
+
+            MessageReader reader = MessageReader.Get(msg.Buffer);
+
+            MessageWriter writer = MessageWriter.Get(SendOption.Reliable);
+            writer.StartMessage(5);
+            writer.Write(TestInsert);
+            writer.EndMessage();
+
+            reader.ReadMessage();
+            var one = reader.ReadMessage();
+            var two = one.ReadMessage();
+            var three = two.ReadMessage();
+
+            two.InsertMessage(three, writer);
+
+            //set the position back to zero to read back the updated message
+            reader.Position = 0;
+
+            var zero = reader.ReadMessage();
+            Assert.AreEqual(Test0, zero.ReadByte());
+            one = reader.ReadMessage();
+            two = one.ReadMessage();
+            var insert = two.ReadMessage();
+            Assert.AreEqual(TestInsert, insert.ReadByte());
+            three = two.ReadMessage();
+            Assert.AreEqual(Test3, three.ReadByte());
+            var four = two.ReadMessage();
+            Assert.AreEqual(Test4, four.ReadByte());
+
+            var five = reader.ReadMessage();
+            Assert.AreEqual(Test5, five.ReadByte());
+        }
+
+        [TestMethod]
+        public void InsertMessageWorksWithSendOptionNone()
+        {
+            const byte Test0 = 11;
+            const byte Test3 = 33;
+            const byte Test4 = 44;
+            const byte Test5 = 55;
+            const byte TestInsert = 66;
+
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(0);
+            msg.Write(Test0);
+            msg.EndMessage();
+
+            msg.StartMessage(12);
+            msg.StartMessage(23);
+
+            msg.StartMessage(34);
+            msg.Write(Test3);
+            msg.EndMessage();
+
+            msg.StartMessage(45);
+            msg.Write(Test4);
+            msg.EndMessage();
+
+            msg.EndMessage();
+            msg.EndMessage();
+
+            msg.StartMessage(56);
+            msg.Write(Test5);
+            msg.EndMessage();
+
+            MessageReader reader = MessageReader.Get(msg.Buffer);
+
+            MessageWriter writer = MessageWriter.Get(SendOption.None);
+            writer.StartMessage(5);
+            writer.Write(TestInsert);
+            writer.EndMessage();
+
+            reader.ReadMessage();
+            var one = reader.ReadMessage();
+            var two = one.ReadMessage();
+            var three = two.ReadMessage();
+
+            two.InsertMessage(three, writer);
+
+            //set the position back to zero to read back the updated message
+            reader.Position = 0;
+
+            var zero = reader.ReadMessage();
+            Assert.AreEqual(Test0, zero.ReadByte());
+            one = reader.ReadMessage();
+            two = one.ReadMessage();
+            var insert = two.ReadMessage();
+            Assert.AreEqual(TestInsert, insert.ReadByte());
+            three = two.ReadMessage();
+            Assert.AreEqual(Test3, three.ReadByte());
+            var four = two.ReadMessage();
+            Assert.AreEqual(Test4, four.ReadByte());
+
+            var five = reader.ReadMessage();
+            Assert.AreEqual(Test5, five.ReadByte());
+
+        }
+
+        [TestMethod]
+        public void InsertMessageWithoutStartMessageInWriter()
+        {
+            const byte Test0 = 11;
+            const byte Test3 = 33;
+            const byte Test4 = 44;
+            const byte Test5 = 55;
+            const byte TestInsert = 66;
+
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(0);
+            msg.Write(Test0);
+            msg.EndMessage();
+
+            msg.StartMessage(12);
+            msg.StartMessage(23);
+
+            msg.StartMessage(34);
+            msg.Write(Test3);
+            msg.EndMessage();
+
+            msg.StartMessage(45);
+            msg.Write(Test4);
+            msg.EndMessage();
+
+            msg.EndMessage();
+            msg.EndMessage();
+
+            msg.StartMessage(56);
+            msg.Write(Test5);
+            msg.EndMessage();
+
+            MessageReader reader = MessageReader.Get(msg.Buffer);
+
+            MessageWriter writer = MessageWriter.Get(SendOption.Reliable);
+            writer.Write(TestInsert);
+
+            reader.ReadMessage();
+            var one = reader.ReadMessage();
+            var two = one.ReadMessage();
+            var three = two.ReadMessage();
+
+            two.InsertMessage(three, writer);
+
+            //set the position back to zero to read back the updated message
+            reader.Position = 0;
+
+            var zero = reader.ReadMessage();
+            Assert.AreEqual(Test0, zero.ReadByte());
+            one = reader.ReadMessage();
+            two = one.ReadMessage();
+            Assert.AreEqual(TestInsert, two.ReadByte());
+            three = two.ReadMessage();
+            Assert.AreEqual(Test3, three.ReadByte());
+            var four = two.ReadMessage();
+            Assert.AreEqual(Test4, four.ReadByte());
+
+            var five = reader.ReadMessage();
+            Assert.AreEqual(Test5, five.ReadByte());
+        }
+
+        [TestMethod]
+        public void InsertMessageWithMultipleMessagesInWriter()
+        {
+            const byte Test0 = 11;
+            const byte Test3 = 33;
+            const byte Test4 = 44;
+            const byte Test5 = 55;
+            const byte TestInsert = 66;
+            const byte TestInsert2 = 77;
+
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(0);
+            msg.Write(Test0);
+            msg.EndMessage();
+
+            msg.StartMessage(12);
+            msg.StartMessage(23);
+
+            msg.StartMessage(34);
+            msg.Write(Test3);
+            msg.EndMessage();
+
+            msg.StartMessage(45);
+            msg.Write(Test4);
+            msg.EndMessage();
+
+            msg.EndMessage();
+            msg.EndMessage();
+
+            msg.StartMessage(56);
+            msg.Write(Test5);
+            msg.EndMessage();
+
+            MessageReader reader = MessageReader.Get(msg.Buffer);
+
+            MessageWriter writer = MessageWriter.Get(SendOption.Reliable);
+            writer.StartMessage(5);
+            writer.Write(TestInsert);
+            writer.EndMessage();
+
+            writer.StartMessage(6);
+            writer.Write(TestInsert2);
+            writer.EndMessage();
+
+            reader.ReadMessage();
+            var one = reader.ReadMessage();
+            var two = one.ReadMessage();
+            var three = two.ReadMessage();
+
+            two.InsertMessage(three, writer);
+
+            //set the position back to zero to read back the updated message
+            reader.Position = 0;
+
+            var zero = reader.ReadMessage();
+            Assert.AreEqual(Test0, zero.ReadByte());
+            one = reader.ReadMessage();
+            two = one.ReadMessage();
+            var insert = two.ReadMessage();
+            Assert.AreEqual(TestInsert, insert.ReadByte());
+            var insert2 = two.ReadMessage();
+            Assert.AreEqual(TestInsert2, insert2.ReadByte());
+            three = two.ReadMessage();
+            Assert.AreEqual(Test3, three.ReadByte());
+            var four = two.ReadMessage();
+            Assert.AreEqual(Test4, four.ReadByte());
+
+            var five = reader.ReadMessage();
+            Assert.AreEqual(Test5, five.ReadByte());
+        }
+
         [TestMethod]
         public void CopySubMessage()
         {

diff --git a/Hazel/MessageReader.cs b/Hazel/MessageReader.cs
index 197473de688116cb64e12f956783966f4c5cb62f..190be12a8a073aa83ce78ebed986a1b658767526 100644 (file)
--- a/Hazel/MessageReader.cs
+++ b/Hazel/MessageReader.cs
@@ -199,17 +199,27 @@ namespace Hazel
                 var headerOffset = reader.Offset - 3;
                 var startOfMessage = reader.Offset;
                 var len = reader.Buffer.Length - startOfMessage;
+                int writerOffset = 3;
+                switch (writer.SendOption)
+                {
+                    case SendOption.Reliable:
+                        writerOffset = 3;
+                        break;
+                    case SendOption.None:
+                        writerOffset = 1;
+                        break;
+                }
                 
                 //store the original buffer in temp
-                Array.Copy(reader.Buffer, startOfMessage, temp.Buffer, 0, len);
+                Array.Copy(reader.Buffer, headerOffset, temp.Buffer, 0, len);
 
                 //put the contents of writer in at headerOffset
-                Array.Copy(writer.Buffer, 3, this.Buffer, headerOffset, writer.Length);
+                Array.Copy(writer.Buffer, writerOffset, this.Buffer, headerOffset, writer.Length-writerOffset);
 
                 //put the original buffer in after that
-                Array.Copy(temp.Buffer, 0, this.Buffer, headerOffset + writer.Length, len - writer.Length);
+                Array.Copy(temp.Buffer, 0, this.Buffer, headerOffset + (writer.Length-writerOffset), len - writer.Length);
 
-                this.AdjustLength(-1 * reader.Offset , -1 * (writer.Length - 3));
+                this.AdjustLength(-1 * reader.Offset , -1 * (writer.Length - writerOffset));
             }
             finally
             {