Make RemoveMessage work

diff --git a/src/Impostor.Hazel/MessageReader.cs b/src/Impostor.Hazel/MessageReader.cs
index e615503ae63f50c180801e1d2d045bc6e2775ecf..d4668db771d3e6778395b03c1d463d085f90dec1 100644 (file)
--- a/src/Impostor.Hazel/MessageReader.cs
+++ b/src/Impostor.Hazel/MessageReader.cs
@@ -188,27 +188,24 @@ namespace Impostor.Hazel
 
         public void RemoveMessage(IMessageReader message)
         {
-            var pool = ArrayPool.Rent(message.Buffer.Length);
+            // Offset of where to start removing.
+            var offsetStart = message.Offset - 3;
 
-            try
-            {
-                var offsetHeader = message.Offset - 3;
-                var offsetEnd = message.Offset + message.Length;
-                var len = message.Buffer.Length - offsetEnd;
+            // Offset of where to end removing.
+            var offsetEnd = message.Offset + message.Length;
 
-                Array.Copy(message.Buffer, offsetEnd, pool, 0, len);
-                Array.Copy(pool, 0, this.Buffer, offsetHeader, len);
+            // The amount of bytes to copy over ourselves.
+            var lengthToCopy = message.Buffer.Length - offsetEnd;
 
-                AdjustLength(message.Offset, message.Length + 3);
-            }
-            finally
-            {
-                ArrayPool.Return(pool);
-            }
+            System.Buffer.BlockCopy(Buffer, offsetEnd, Buffer, offsetStart, lengthToCopy);
+
+            ((MessageReader) message).Parent.AdjustLength(message.Offset, message.Length + 3);
         }
 
         private void AdjustLength(int offset, int amount)
         {
+            this.Length -= amount;
+
             if (this.ReadPosition > offset)
             {
                 this.Position -= amount;
@@ -217,11 +214,10 @@ namespace Impostor.Hazel
             if (Parent != null)
             {
                 var lengthOffset = this.Offset - 3;
-                var curLen = this.Buffer[lengthOffset]
-                             | (this.Buffer[lengthOffset + 1] << 8);
+                var curLen = this.Buffer[lengthOffset] |
+                             (this.Buffer[lengthOffset + 1] << 8);
 
                 curLen -= amount;
-                this.Length -= amount;
 
                 this.Buffer[lengthOffset] = (byte)curLen;
                 this.Buffer[lengthOffset + 1] = (byte)(this.Buffer[lengthOffset + 1] >> 8);

diff --git a/src/Impostor.Tests/Hazel/MessageReaderTests.cs b/src/Impostor.Tests/Hazel/MessageReaderTests.cs
index a51b8bff2671755412f27ce8d69ec6cff4054c63..2241fb90f65e16d14d6fed548473527681f4148b 100644 (file)
--- a/src/Impostor.Tests/Hazel/MessageReaderTests.cs
+++ b/src/Impostor.Tests/Hazel/MessageReaderTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using Impostor.Hazel;
 using Impostor.Hazel.Extensions;
 using Microsoft.Extensions.DependencyInjection;
@@ -7,7 +8,7 @@ using Xunit;
 
 namespace Impostor.Tests.Hazel
 {
-    public class BufferMessageReaderTests
+    public class MessageReaderTests
     {
         private ObjectPool<MessageReader> CreateReaderPool()
         {
@@ -288,10 +289,10 @@ namespace Impostor.Tests.Hazel
 
             messageExpected.StartMessage(0);
             messageExpected.StartMessage(1);
-            messageExpected.Write("HiTest");
+            messageExpected.Write("HiTest1");
             messageExpected.EndMessage();
             messageExpected.StartMessage(2);
-            messageExpected.Write("HiTest");
+            messageExpected.Write("HiTest2");
             messageExpected.EndMessage();
             messageExpected.EndMessage();
 
@@ -310,10 +311,14 @@ namespace Impostor.Tests.Hazel
                 messageWriter.EndMessage();
             messageWriter.EndMessage();
 
+            // Copy buffer.
+            var bufferCopy = new byte[messageWriter.Length];
+            Buffer.BlockCopy(messageWriter.Buffer, 0, bufferCopy, 0, bufferCopy.Length);
+
             // Do the magic.
             var readerPool = CreateReaderPool();
             var reader = readerPool.Get();
-            reader.Update(messageWriter.Buffer);
+            reader.Update(bufferCopy);
             var inner = reader.ReadMessage();
 
             while (inner.Position < inner.Length)
@@ -336,10 +341,15 @@ namespace Impostor.Tests.Hazel
                 {
                     Assert.Equal("HiTest2", message.ReadString());
                 }
+                else
+                {
+                    Assert.True(false, "Invalid tag was read.");
+                }
             }
 
             // Check if the magic was successful.
-            Assert.Equal(messageExpected.ToByteArray(true), messageWriter.ToByteArray(true));
+            Assert.Equal(messageExpected.Length, reader.Length);
+            Assert.Equal(messageExpected.ToByteArray(true), reader.Buffer.Take(reader.Length).ToArray());
         }
 
         [Fact]