1 files changed, 213 insertions, 0 deletions
diff --git a/Tools/Hazel-Networking/Hazel.UnitTests/MessageWriterTests.cs b/Tools/Hazel-Networking/Hazel.UnitTests/MessageWriterTests.cs
new file mode 100644
index 0000000..b292a5d
--- /dev/null
+++ b/Tools/Hazel-Networking/Hazel.UnitTests/MessageWriterTests.cs
@@ -0,0 +1,213 @@
+using System;
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Hazel.UnitTests
+{
+    [TestClass]
+    public class MessageWriterTests
+    {
+
+        [TestMethod]
+        public void CancelMessages()
+        {
+            var msg = new MessageWriter(128);
+
+            msg.StartMessage(1);
+            msg.Write(32);
+
+            msg.StartMessage(2);
+            msg.Write(2);
+            msg.CancelMessage();
+
+            Assert.AreEqual(7, msg.Length);
+            Assert.IsFalse(msg.HasBytes(7));
+
+            msg.CancelMessage();
+
+            Assert.AreEqual(0, msg.Length);
+            Assert.IsFalse(msg.HasBytes(1));
+        }
+
+        [TestMethod]
+        public void HasBytes()
+        {
+            var msg = new MessageWriter(128);
+
+            msg.StartMessage(1);
+            msg.Write(32);
+
+            msg.StartMessage(2);
+            msg.Write(2);
+            msg.EndMessage();
+
+            // Assert.AreEqual(7, msg.Length);
+            Assert.IsTrue(msg.HasBytes(7));
+        }
+
+        [TestMethod]
+        public void WriteProperInt()
+        {
+            const int Test1 = int.MaxValue;
+            const int Test2 = int.MinValue;
+
+            var msg = new MessageWriter(128);
+            msg.Write(Test1);
+            msg.Write(Test2);
+
+            Assert.AreEqual(8, msg.Length);
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            using (MemoryStream m = new MemoryStream(msg.Buffer, 0, msg.Length))
+            using (BinaryReader reader = new BinaryReader(m))
+            {
+                Assert.AreEqual(Test1, reader.ReadInt32());
+                Assert.AreEqual(Test2, reader.ReadInt32());
+            }
+        }
+
+        [TestMethod]
+        public void WriteProperBool()
+        {
+            const bool Test1 = true;
+            const bool Test2 = false;
+
+            var msg = new MessageWriter(128);
+            msg.Write(Test1);
+            msg.Write(Test2);
+
+            Assert.AreEqual(2, msg.Length);
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            using (MemoryStream m = new MemoryStream(msg.Buffer, 0, msg.Length))
+            using (BinaryReader reader = new BinaryReader(m))
+            {
+                Assert.AreEqual(Test1, reader.ReadBoolean());
+                Assert.AreEqual(Test2, reader.ReadBoolean());
+            }
+        }
+
+        [TestMethod]
+        public void WriteProperString()
+        {
+            const string Test1 = "Hello";
+            string Test2 = new string(' ', 1024);
+            var msg = new MessageWriter(2048);
+            msg.Write(Test1);
+            msg.Write(Test2);
+            msg.Write(string.Empty);
+
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            using (MemoryStream m = new MemoryStream(msg.Buffer, 0, msg.Length))
+            using (BinaryReader reader = new BinaryReader(m))
+            {
+                Assert.AreEqual(Test1, reader.ReadString());
+                Assert.AreEqual(Test2, reader.ReadString());
+                Assert.AreEqual(string.Empty, reader.ReadString());
+            }
+        }
+
+        [TestMethod]
+        public void WriteProperFloat()
+        {
+            const float Test1 = 12.34f;
+
+            var msg = new MessageWriter(2048);
+            msg.Write(Test1);
+
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            using (MemoryStream m = new MemoryStream(msg.Buffer, 0, msg.Length))
+            using (BinaryReader reader = new BinaryReader(m))
+            {
+                Assert.AreEqual(Test1, reader.ReadSingle());
+            }
+        }
+
+        [TestMethod]
+        public void WritePackedUint()
+        {
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(0);
+            msg.WritePacked(8u);
+            msg.WritePacked(250u);
+            msg.WritePacked(68000u);
+            msg.EndMessage();
+
+            Assert.AreEqual(3 + 1 + 2 + 3, msg.Position);
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            MessageReader reader = MessageReader.Get(msg.Buffer, 0);
+
+            Assert.AreEqual(8u, reader.ReadPackedUInt32());
+            Assert.AreEqual(250u, reader.ReadPackedUInt32());
+            Assert.AreEqual(68000u, reader.ReadPackedUInt32());
+        }
+
+        [TestMethod]
+        public void WritePackedInt()
+        {
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(0);
+            msg.WritePacked(8);
+            msg.WritePacked(250);
+            msg.WritePacked(68000);
+            msg.WritePacked(60168000);
+            msg.WritePacked(-68000);
+            msg.WritePacked(-250);
+            msg.WritePacked(-8);
+
+            msg.WritePacked(0);
+            msg.WritePacked(-1);
+            msg.WritePacked(int.MinValue);
+            msg.WritePacked(int.MaxValue);
+            msg.EndMessage();
+
+            Assert.AreEqual(3 + 1 + 2 + 3 + 4 + 5 + 5 + 5 + 1 + 5 + 5 + 5, msg.Position);
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            MessageReader reader = MessageReader.Get(msg.Buffer, 0);
+
+            Assert.AreEqual(8, reader.ReadPackedInt32());
+            Assert.AreEqual(250, reader.ReadPackedInt32());
+            Assert.AreEqual(68000, reader.ReadPackedInt32());
+            Assert.AreEqual(60168000, reader.ReadPackedInt32());
+
+            Assert.AreEqual(-68000, reader.ReadPackedInt32());
+            Assert.AreEqual(-250, reader.ReadPackedInt32());
+            Assert.AreEqual(-8, reader.ReadPackedInt32());
+
+            Assert.AreEqual(0, reader.ReadPackedInt32());
+            Assert.AreEqual(-1, reader.ReadPackedInt32());
+            Assert.AreEqual(int.MinValue, reader.ReadPackedInt32());
+            Assert.AreEqual(int.MaxValue, reader.ReadPackedInt32());
+        }
+
+        [TestMethod]
+        public void WritesMessageLength()
+        {
+            var msg = new MessageWriter(2048);
+            msg.StartMessage(1);
+            msg.Write(65534);
+            msg.EndMessage();
+
+            Assert.AreEqual(2 + 1 + 4, msg.Position);
+            Assert.AreEqual(msg.Length, msg.Position);
+
+            using (MemoryStream m = new MemoryStream(msg.Buffer, 0, msg.Length))
+            using (BinaryReader reader = new BinaryReader(m))
+            {
+                Assert.AreEqual(4, reader.ReadUInt16()); // Length After Type and Target
+                Assert.AreEqual(1, reader.ReadByte()); // Type
+                Assert.AreEqual(65534, reader.ReadInt32()); // Content
+            }
+        }
+
+        [TestMethod]
+        public void GetLittleEndian()
+        {
+            Assert.IsTrue(MessageWriter.IsLittleEndian());
+        }
+    }
+}