Merge pull request #89 from paulpach/floattest

Add tests for floating points serialization

Author: GabrielTofvesson

MLAPI.Tests/NetworkingManagerComponents/Binary/BitStreamTest.cs

@@ -27,6 +27,31 @@ public void TestBool()
             Assert.That(bitStream.Length, Is.EqualTo(100));
         }
 
+        [Test]
+        public void TestSetLength()
+        {
+            BitStream bitStream = new BitStream(4);
+            bitStream.SetLength(100);
+
+            Assert.That(bitStream.Capacity, Is.GreaterThanOrEqualTo(100));
+        }
+
+        [Test]
+        public void TestSetLength2()
+        {
+            BitStream bitStream = new BitStream(4);
+
+            bitStream.WriteByte(1);
+            bitStream.WriteByte(1);
+            bitStream.WriteByte(1);
+            bitStream.WriteByte(1);
+
+            bitStream.SetLength(0);
+
+            // position should never go beyond length
+            Assert.That(bitStream.Position, Is.EqualTo(0));
+        }
+
         [Test]
         public void TestGrow()
         {
@@ -161,9 +186,6 @@ public void TestInOutBytes()
             BitStream outStream = new BitStream(buffer);
             outStream.WriteByte(someNumber);
 
-
-            // the bit should now be stored in the buffer,  lets see if it comes out
-
             BitStream inStream = new BitStream(buffer);
             Assert.That(inStream.ReadByte(), Is.EqualTo(someNumber));
 
@@ -182,9 +204,6 @@ public void TestInOutInt16()
             BitStream outStream = new BitStream(buffer);
             outStream.WriteInt16(someNumber);
 
-
-            // the bit should now be stored in the buffer,  lets see if it comes out
-
             BitStream inStream = new BitStream(buffer);
             short result = inStream.ReadInt16();
 
@@ -202,11 +221,25 @@ public void TestInOutInt32()
             BitStream outStream = new BitStream(buffer);
             outStream.WriteInt32(someNumber);
 
+            BitStream inStream = new BitStream(buffer);
+            int result = inStream.ReadInt32();
+
+            Assert.That(result, Is.EqualTo(someNumber));
+        }
+
+        [Test]
+        public void TestInOutInt64()
+        {
+            byte[] buffer = new byte[100];
+
+            long someNumber = 4614256656552045848;
 
-            // the bit should now be stored in the buffer,  lets see if it comes out
+
+            BitStream outStream = new BitStream(buffer);
+            outStream.WriteInt64(someNumber);
 
             BitStream inStream = new BitStream(buffer);
-            int result = inStream.ReadInt32();
+            long result = inStream.ReadInt64();
 
             Assert.That(result, Is.EqualTo(someNumber));
         }
@@ -267,5 +300,68 @@ public void TestCapacityGrowth()
             Assert.That(inStream.Length, Is.EqualTo(5));
             Assert.That(inStream.Capacity, Is.GreaterThanOrEqualTo(5));
         }
+
+        [Test]
+        public void TestWriteSingle()
+        {
+            float somenumber = 0.1f;
+            BitStream outStream = new BitStream();
+
+            outStream.WriteSingle(somenumber);
+            byte[] buffer = outStream.GetBuffer();
+
+            BitStream inStream = new BitStream(buffer);
+
+            Assert.That(inStream.ReadSingle(), Is.EqualTo(somenumber));
+        }
+
+        [Test]
+        public void TestWriteDouble()
+        {
+            double somenumber = Math.PI;
+            BitStream outStream = new BitStream();
+
+            outStream.WriteDouble(somenumber);
+            byte[] buffer = outStream.GetBuffer();
+
+            BitStream inStream = new BitStream(buffer);
+
+            Assert.That(inStream.ReadDouble(), Is.EqualTo(somenumber));
+
+        }
+
+        [Test]
+        public void TestWriteMisaligned()
+        {
+            BitStream outStream = new BitStream();
+            outStream.WriteBit(true);
+            outStream.WriteBit(false);
+            // now the stream is misalligned,  lets write some bytes
+            outStream.WriteByte(244);
+            outStream.WriteByte(123);
+            outStream.WriteInt16(-5457);
+            outStream.WriteUInt64(4773753249);
+            outStream.WriteUInt64Packed(5435285812313212);
+            outStream.WriteInt64Packed(-5435285812313212);
+            outStream.WriteBit(true);
+            outStream.WriteByte(1);
+            outStream.WriteByte(0);
+
+            byte[] buffer = outStream.GetBuffer();
+
+            BitStream inStream = new BitStream(buffer);
+
+            Assert.That(inStream.ReadBit(), Is.True);
+            Assert.That(inStream.ReadBit(), Is.False);
+            Assert.That(inStream.ReadByte(), Is.EqualTo(244));
+            Assert.That(inStream.ReadByte(), Is.EqualTo(123));
+            Assert.That(inStream.ReadInt16(), Is.EqualTo(-5457));
+            Assert.That(inStream.ReadUInt64(), Is.EqualTo(4773753249));
+            Assert.That(inStream.ReadUInt64Packed(), Is.EqualTo(5435285812313212));
+            Assert.That(inStream.ReadInt64Packed(), Is.EqualTo(-5435285812313212));
+            Assert.That(inStream.ReadBit(), Is.True);
+            Assert.That(inStream.ReadByte(), Is.EqualTo(1));
+            Assert.That(inStream.ReadByte(), Is.EqualTo(0));
+        }
     }
 }

MLAPI/NetworkingManagerComponents/Binary/BitStream.cs

@@ -67,7 +67,7 @@ public BitStream(byte[] target)
         {
             this.target = target;
             Resizable = false;
-            BitLength = (ulong) (target.Length << 3);
+            BitLength = (ulong)(target.Length << 3);
         }
 
         /// <summary>
@@ -99,15 +99,16 @@ public BitStream(byte[] target)
         /// <summary>
         /// Current buffer size. The buffer will not be resized (if possible) until Position is equal to Capacity and an attempt to write data is made.
         /// </summary>
-        public long Capacity {
+        public long Capacity
+        {
             get => target.LongLength; // Optimized CeilingExact
             set
             {
                 if (value < Length) throw new ArgumentOutOfRangeException("New capcity too small!");
                 SetCapacity(value);
             }
         }
-        
+
         /// <summary>
         /// The current length of data considered to be "written" to the buffer.
         /// </summary>
@@ -116,7 +117,7 @@ public long Capacity {
         /// <summary>
         /// The index that will be written to when any call to write data is made to this stream.
         /// </summary>
-        public override long Position { get => (long)(BitPosition>>3); set => BitPosition = (ulong)value << 3; }
+        public override long Position { get => (long)(BitPosition >> 3); set => BitPosition = (ulong)value << 3; }
 
         /// <summary>
         /// Bit offset into the buffer that new data will be written to.
@@ -146,7 +147,7 @@ public override void Flush() { } // NOP
         private byte ReadByteMisaligned()
         {
             int mod = (int)(BitPosition & 7);
-            return (byte)((target[(int)Position++] >> mod) | (target[(int)Position] << (8 - mod)));
+            return (byte)((target[(int)Position] >> mod) | (target[(int)(BitPosition += 8) >> 3] << (8 - mod)));
         }
         /// <summary>
         /// Read an aligned byte from the buffer. It's recommended to not use this when the BitPosition is byte-misaligned.
@@ -224,8 +225,9 @@ private void SetCapacity(long value)
         public override void SetLength(long value)
         {
             if (value < 0) throw new IndexOutOfRangeException("Cannot set a negative length!");
-            if (value > Capacity) Grow(value-Capacity);
+            if (value > Capacity) Grow(value - Capacity);
             BitLength = (ulong)value << 3;
+            BitPosition = Math.Min((ulong)value << 3, BitPosition);
         }
 
         /// <summary>
@@ -271,7 +273,7 @@ public void WriteBit(bool bit)
         {
             if (BitAligned && Position == target.Length) Grow(1);
             int offset = (int)(BitPosition & 7);
-            ulong pos = BitPosition >> 3;
+            long pos = Position;
             ++BitPosition;
             target[pos] = (byte)(bit ? (target[pos] & ~(1 << offset)) | (1 << offset) : (target[pos] & ~(1 << offset)));
             UpdateLength();
@@ -313,7 +315,7 @@ public void WriteDouble(double value)
         /// <param name="value">Value to write</param>
         public void WriteSinglePacked(float value)
         {
-            lock(holder_f)
+            lock (holder_f)
                 lock (holder_i)
                 {
                     holder_f[0] = value;
@@ -470,8 +472,8 @@ public void WriteRangedSingle(float value, float minValue, float maxValue, int b
         {
             if (bytes < 1 || bytes > 4) throw new ArgumentOutOfRangeException("Result must occupy between 1 and 4 bytes!");
             if (value < minValue || value > maxValue) throw new ArgumentOutOfRangeException("Given value does not match the given constraints!");
-            uint result = (uint)(((value + minValue)/(maxValue+minValue))*((0x100*bytes) - 1));
-            for (int i = 0; i < bytes; ++i) _WriteByte((byte)(result >> (i<<3)));
+            uint result = (uint)(((value + minValue) / (maxValue + minValue)) * ((0x100 * bytes) - 1));
+            for (int i = 0; i < bytes; ++i) _WriteByte((byte)(result >> (i << 3)));
         }
 
         /// <summary>
@@ -485,7 +487,7 @@ public void WriteRangedDouble(double value, double minValue, double maxValue, in
         {
             if (bytes < 1 || bytes > 8) throw new ArgumentOutOfRangeException("Result must occupy between 1 and 8 bytes!");
             if (value < minValue || value > maxValue) throw new ArgumentOutOfRangeException("Given value does not match the given constraints!");
-            ulong result = (ulong)(((value + minValue) / (maxValue+minValue)) * ((0x100 * bytes) - 1));
+            ulong result = (ulong)(((value + minValue) / (maxValue + minValue)) * ((0x100 * bytes) - 1));
             for (int i = 0; i < bytes; ++i) _WriteByte((byte)(result >> (i << 3)));
         }
 
@@ -497,7 +499,7 @@ public void WriteRangedDouble(double value, double minValue, double maxValue, in
         public void WriteRotation(Quaternion rotation, int bytesPerAngle)
         {
             if (bytesPerAngle < 1 || bytesPerAngle > 4) throw new ArgumentOutOfRangeException("Bytes per angle must be at least 1 byte and at most 4 bytes!");
-            if (bytesPerAngle==4) WriteVector3(rotation.eulerAngles);
+            if (bytesPerAngle == 4) WriteVector3(rotation.eulerAngles);
             else
             {
                 Vector3 rot = rotation.eulerAngles;
@@ -539,15 +541,15 @@ public double ReadDouble()
                     return holder_d[0];
                 }
         }
-        
+
         /// <summary>
         /// Read a single-precision floating point value from the stream from a varint
         /// </summary>
         /// <returns>The read value</returns>
         public float ReadSinglePacked()
         {
             uint read = ReadUInt32Packed();
-            lock(holder_f)
+            lock (holder_f)
                 lock (holder_i)
                 {
                     holder_i[0] = BinaryHelpers.SwapEndian(read);
@@ -700,7 +702,7 @@ public void WriteNibble(byte value)
                 value &= 0x0F;
                 int offset = (int)(BitPosition & 7), offset_inv = 8 - offset;
                 target[Position] = (byte)((target[Position] & (0xFF >> offset_inv)) | (byte)(value << offset));
-                if(offset > 4) target[Position + 1] = (byte)((target[Position + 1] & (0xFF << (offset & 3))) | (byte)(value >> offset_inv));
+                if (offset > 4) target[Position + 1] = (byte)((target[Position + 1] & (0xFF << (offset & 3))) | (byte)(value >> offset_inv));
                 BitPosition += 4;
             }
             UpdateLength();
@@ -719,13 +721,13 @@ public void WriteNibble(byte value)
         /// <param name="bitCount">Amount of bits to write</param>
         public void WriteBits(ulong value, int bitCount)
         {
-            if (BitPosition + (ulong)bitCount > ((ulong)target.LongLength << 3)) Grow(Div8Ceil(BitPosition+(ulong)bitCount));
+            if (BitPosition + (ulong)bitCount > ((ulong)target.LongLength << 3)) Grow(Div8Ceil(BitPosition + (ulong)bitCount));
             if (bitCount > 64) throw new ArgumentOutOfRangeException("Cannot read more than 64 bits from a 64-bit value!");
             if (bitCount < 0) throw new ArgumentOutOfRangeException("Cannot read fewer than 0 bits!");
             int count = -8;
-            while (bitCount > (count+=8)) _WriteULongByte(value >> count);
+            while (bitCount > (count += 8)) _WriteULongByte(value >> count);
             BitPosition += (ulong)count;
-            if((bitCount & 7) != 0) _WriteBits((byte)(value >> count), bitCount & 7);
+            if ((bitCount & 7) != 0) _WriteBits((byte)(value >> count), bitCount & 7);
             UpdateLength();
         }
         /// <summary>
@@ -743,7 +745,7 @@ private void _WriteBits(byte value, int bitCount)
             target[Position] = (byte)(
                     (target[Position] & (0xFF >> offset_inv)) |             // Bits prior to value (lower)
                     (target[Position] & (0xFF << (offset + bitCount))) |    // Bits after value (higher)
-                    (value<<offset)                                         // Bits to write
+                    (value << offset)                                         // Bits to write
                 );
             if (bitCount + offset > 8)
                 target[Position + 1] = (byte)(
@@ -906,15 +908,15 @@ public void WriteUInt64Packed(ulong value)
         /// Read an unsigned long (UInt64) from the stream.
         /// </summary>
         /// <returns>Value read from stream.</returns>
-        public ulong ReadUInt64() => (ulong)(
+        public ulong ReadUInt64() => (
                 _ReadByte() |
-                (_ReadByte() << 8) |
-                (_ReadByte() << 16) |
-                (_ReadByte() << 24) |
-                (_ReadByte() << 32) |
-                (_ReadByte() << 40) |
-                (_ReadByte() << 48) |
-                (_ReadByte() << 56)
+                ((ulong)_ReadByte() << 8) |
+                ((ulong)_ReadByte() << 16) |
+                ((ulong)_ReadByte() << 24) |
+                ((ulong)_ReadByte() << 32) |
+                ((ulong)_ReadByte() << 40) |
+                ((ulong)_ReadByte() << 48) |
+                ((ulong)_ReadByte() << 56)
                 );
         /// <summary>
         /// Read a signed long (Int64) from the stream.
@@ -982,7 +984,7 @@ private void _WriteMisaligned(byte value)
         {
             int off = (int)(BitPosition & 7);
             int shift1 = 8 - off;
-            target[Position + 1] = (byte)((target[Position + 1] & (0xFF >> off)) | (value >> shift1));
+            target[Position + 1] = (byte)((target[Position + 1] & (0xFF << off)) | (value >> shift1));
             target[Position] = (byte)((target[Position] & (0xFF >> shift1)) | (value << off));
 
             BitPosition += 8;
@@ -1054,19 +1056,19 @@ public override void WriteByte(byte value)
         /// <param name="count">How many bytes to read. Set to value less than one to read until ReadByte returns -1</param>
         public void CopyFrom(Stream s, int count = -1)
         {
-            if(s is BitStream b) Write(b.target, 0, count < 0 ? (int)b.Length : count);
+            if (s is BitStream b) Write(b.target, 0, count < 0 ? (int)b.Length : count);
             else
             {
                 int read;
                 bool readToEnd = count < 0;
-                while((readToEnd || count-- > 0) && (read = s.ReadByte()) != -1)
+                while ((readToEnd || count-- > 0) && (read = s.ReadByte()) != -1)
                     _WriteIntByte(read);
                 UpdateLength();
             }
         }
-        
+
         // TODO: Implement CopyFrom() for BitStream with bitCount parameter
-        
+
         /// <summary>
         /// Update length of data considered to be "written" to the stream.
         /// </summary>