fix: Fixes unaligned BitReader reads when reading >= 8 bits. (#1240)

* fix: Fixes unaligned BitReader reads when reading >= 8 bits.

Also adds tests to exercise that case.

* Why didn't standards.py --fix fix this the first time I ran it?

Author: ShadauxCat

com.unity.netcode.gameobjects/Runtime/Serialization/BitReader.cs

@@ -212,7 +212,7 @@ private unsafe void ReadMisaligned(out byte value)
             int pos = m_BitPosition >> 3;
             int shift1 = 8 - off;
 
-            value = (byte)((m_BufferPointer[pos] >> shift1) | (m_BufferPointer[(m_BitPosition += 8) >> 3] << shift1));
+            value = (byte)((m_BufferPointer[pos] >> off) | (m_BufferPointer[(m_BitPosition += 8) >> 3] << shift1));
         }
     }
 }

com.unity.netcode.gameobjects/Tests/Editor/Serialization/BitReaderTests.cs

@@ -288,6 +288,34 @@ public unsafe void TestReadingMultipleBytesToLongs([Range(1U, 64U)] uint numBits
             }
         }
 
+        [Test]
+        public unsafe void TestReadingMultipleBytesToLongsMisaligned([Range(1U, 63U)] uint numBits)
+        {
+            ulong value = 0b01010101_10101010_01010101_10101010_01010101_10101010_01010101_10101010;
+            var reader = new FastBufferReader((byte*)&value, Allocator.Temp, sizeof(ulong));
+            using (reader)
+            {
+                ulong* asUlong = (ulong*)reader.GetUnsafePtr();
+
+                Assert.AreEqual(value, *asUlong);
+                var mask = 0UL;
+                for (var i = 0; i < numBits; ++i)
+                {
+                    mask |= (1UL << i);
+                }
+
+                ulong readValue;
+
+                Assert.IsTrue(reader.TryBeginRead(sizeof(ulong)));
+                using (var bitReader = reader.EnterBitwiseContext())
+                {
+                    bitReader.ReadBit(out bool unused);
+                    bitReader.ReadBits(out readValue, numBits);
+                }
+                Assert.AreEqual((value >> 1) & mask, readValue);
+            }
+        }
+
         [Test]
         public unsafe void TestReadingBitsThrowsIfTryBeginReadNotCalled()
         {

com.unity.netcode.gameobjects/Tests/Editor/Serialization/BitWriterTests.cs

@@ -243,6 +243,33 @@ public unsafe void TestWritingMultipleBytesFromLongs([Range(1U, 64U)] uint numBi
             }
         }
 
+        [Test]
+        public unsafe void TestWritingMultipleBytesFromLongsMisaligned([Range(1U, 63U)] uint numBits)
+        {
+            var writer = new FastBufferWriter(sizeof(ulong), Allocator.Temp);
+            using (writer)
+            {
+                ulong* asUlong = (ulong*)writer.GetUnsafePtr();
+
+                Assert.AreEqual(0, *asUlong);
+                var mask = 0UL;
+                for (var i = 0; i < numBits; ++i)
+                {
+                    mask |= (1UL << i);
+                }
+
+                ulong value = 0xFFFFFFFFFFFFFFFF;
+
+                Assert.IsTrue(writer.TryBeginWrite(sizeof(ulong)));
+                using (var bitWriter = writer.EnterBitwiseContext())
+                {
+                    bitWriter.WriteBit(false);
+                    bitWriter.WriteBits(value, numBits);
+                }
+                Assert.AreEqual(value & mask, *asUlong >> 1);
+            }
+        }
+
         [Test]
         public unsafe void TestWritingBitsThrowsIfTryBeginWriteNotCalled()
         {