multiplayer refactor

Tests/Runtime/Engine/NetworkBufferWriterReaderTests.cs

@@ -0,0 +1,204 @@
+using NUnit.Framework;
+using RebootKit.Engine.Extensions;
+using RebootKit.Engine.Foundation;
+using RebootKit.Engine.Network;
+using Unity.Collections;
+using UnityEngine;
+
+namespace Tests.Runtime.Engine {
+    public class NetworkBufferWriterReaderTests {
+        [Test]
+        public void NetworkBuffer_Int() {
+            const int k_Value = 12345;
+
+            using NativeArray<byte> data = new NativeArray<byte>(4, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out int value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_Two_Ints() {
+            const int k_Value1 = 12345;
+            const int k_Value2 = 67890;
+
+            using NativeArray<byte> data = new NativeArray<byte>(8, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value1);
+            writer.Write(k_Value2);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out int value1));
+            Assert.AreEqual(k_Value1, value1);
+            Assert.IsTrue(reader.Read(out int value2));
+            Assert.AreEqual(k_Value2, value2);
+        }
+
+        [Test]
+        public void NetworkBuffer_Short() {
+            const short k_Value = 123;
+
+            using NativeArray<byte> data = new NativeArray<byte>(2, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out short value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_UShort() {
+            const ushort k_Value = 123;
+            using NativeArray<byte> data = new NativeArray<byte>(2, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out ushort value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_Long() {
+            const long k_Value = 123456789L;
+
+            using NativeArray<byte> data = new NativeArray<byte>(8, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out long value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_ULong() {
+            const ulong k_Value = 123456789UL;
+
+            using NativeArray<byte> data = new NativeArray<byte>(8, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out ulong value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_Bool() {
+            const bool k_Value = true;
+
+            using NativeArray<byte> data = new NativeArray<byte>(1, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out bool value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_Byte() {
+            const byte k_Value = 0xAB;
+
+            using NativeArray<byte> data = new NativeArray<byte>(1, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out byte value));
+            Assert.AreEqual(k_Value, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_Float() {
+            const float k_Value = 123.45f;
+            using NativeArray<byte> data = new NativeArray<byte>(4, Allocator.Temp);
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(k_Value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out float value));
+            Assert.AreEqual(k_Value, value, 0.0001f);
+        }
+
+        [Test]
+        public void NetworkBuffer_ReadBeyond() {
+            using NativeArray<byte> data = new NativeArray<byte>(4, Allocator.Temp);
+
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(12345);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out int value));
+            Assert.AreEqual(12345, value);
+
+            Assert.IsFalse(reader.Read(out int _));
+        }
+
+        [Test]
+        public void NetworkBuffer_FixedString32Bytes() {
+            FixedString32Bytes value = new FixedString32Bytes("henlo_world");
+
+            using NativeArray<byte> data = new NativeArray<byte>(32, Allocator.Temp);
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write(value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsTrue(reader.Read(out FixedString32Bytes readValue), "Failed to read FixedString32Bytes");
+            Assert.IsTrue(value == readValue, "Value should be equal to read value");
+        }
+
+        [Test]
+        public void NetworkBuffer_Empty() {
+            using NativeArray<byte> data = new NativeArray<byte>(0, Allocator.Temp);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            Assert.IsFalse(reader.Read(out int value));
+            Assert.AreEqual(0, value);
+        }
+
+        [Test]
+        public void NetworkBuffer_Size_NativeArray() {
+            NativeArray<byte> value = new NativeArray<byte>(new byte[] {
+                1,
+                2,
+                3,
+                4,
+                5
+            }, Allocator.Temp);
+
+            using NativeArray<byte> data = new NativeArray<byte>(value.Length + sizeof(ushort), Allocator.Temp);
+            using NetworkBufferWriter writer = new NetworkBufferWriter(data, 0);
+            writer.Write((ushort) value.Length);
+            writer.Write(value);
+
+            using NetworkBufferReader reader = new NetworkBufferReader(data);
+            reader.Read(out ushort readLength);
+            Assert.IsTrue(readLength == value.Length,
+                          $"Read Length({readLength }) should be equal to an actual value.length({value.Length})");
+            Assert.IsTrue(reader.Read(out NativeArray<byte> readValue, readLength), "Failed to read NativeArray<byte>");
+            Assert.AreEqual(value.Length, readValue.Length,
+                            "Length of read NativeArray<byte> should match written length");
+
+            for (int i = 0; i < value.Length; i++) {
+                Assert.AreEqual(value[i], readValue[i], $"Value at index {i} should match");
+            }
+
+            value.Dispose();
+            readValue.Dispose();
+        }
+    }
+}

Tests/Runtime/Engine/NetworkBufferWriterReaderTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8f01bbcc978f4b9993c29d389987bc9c
+timeCreated: 1752874442

Tests/Runtime/Engine/RebootKit.Engine.Tests.asmdef

@@ -1,20 +1,21 @@
 {
-  "name": "RebootKit.Engine.Tests",
-  "rootNamespace": "",
-  "references": [
-    "GUID:284059c7949783646b281a1b815580e6",
-    "GUID:0acc523941302664db1f4e527237feb3",
-    "GUID:27619889b8ba8c24980f49ee34dbb44a"
-  ],
-  "includePlatforms": [
-    "Editor"
-  ],
-  "excludePlatforms": [],
-  "allowUnsafeCode": false,
-  "overrideReferences": false,
-  "precompiledReferences": [],
-  "autoReferenced": true,
-  "defineConstraints": [],
-  "versionDefines": [],
-  "noEngineReferences": false
+    "name": "RebootKit.Engine.Tests",
+    "rootNamespace": "",
+    "references": [
+        "GUID:284059c7949783646b281a1b815580e6",
+        "GUID:0acc523941302664db1f4e527237feb3",
+        "GUID:e0cd26848372d4e5c891c569017e11f1",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
 }