Added tests

Added constructors
Fixed CanRead
Fixed CopyFrom

Author: GabrielTofvesson

MLAPI.Tests/NetworkingManagerComponents/Binary/BitStreamTest.cs

@@ -59,26 +59,98 @@ public void TestInOutBool()
         }
 
 
+        [Test]
+        public void TestIntOutPacked16Bit()
+        {
+            short svalue = -31934;
+            ushort uvalue = 64893;
+            BitStream outStream = new BitStream();
+            outStream.WriteInt16Packed(svalue);
+            outStream.WriteUInt16Packed(uvalue);
+
+            BitStream inStream = new BitStream(outStream.GetBuffer());
+            Assert.That(inStream.ReadInt16Packed(), Is.EqualTo(svalue));
+            Assert.That(inStream.ReadUInt16Packed(), Is.EqualTo(uvalue));
+        }
+
+
+        [Test]
+        public void TestIntOutPacked32Bit()
+        {
+            int svalue = -100913642;
+            uint uvalue = 1467867235;
+            BitStream outStream = new BitStream();
+            outStream.WriteInt32Packed(svalue);
+            outStream.WriteUInt32Packed(uvalue);
+
+            BitStream inStream = new BitStream(outStream.GetBuffer());
+            Assert.That(inStream.ReadInt32Packed(), Is.EqualTo(svalue));
+            Assert.That(inStream.ReadUInt32Packed(), Is.EqualTo(uvalue));
+        }
+
+
         [Test]
         public void TestInOutPacked64Bit()
         {
             byte[] buffer = new byte[100];
 
-            long someNumber = 1469598103934656037;
+            long someNumber = -1469598103934656037;
+            ulong uNumber = 81246971249124124;
 
 
             BitStream outStream = new BitStream(buffer);
             outStream.WriteInt64Packed(someNumber);
+            outStream.WriteUInt64Packed(uNumber);
 
 
             // the bit should now be stored in the buffer,  lets see if it comes out
 
             BitStream inStream = new BitStream(buffer);
             long result = inStream.ReadInt64Packed();
+            ulong result1 = inStream.ReadUInt64Packed();
 
             Assert.That(result, Is.EqualTo(someNumber));
+            Assert.That(result1, Is.EqualTo(uNumber));
         }
 
+        [Test]
+        public void TestStreamCopy()
+        {
+            BitStream inStream = new BitStream();
+            BitStream copyFrom = new BitStream();
+
+            byte initialValue1 = 56;
+            byte initialValue2 = 24;
+
+            inStream.WriteByte(initialValue1);
+            inStream.WriteByte(initialValue2);
+
+            byte copyValue1 = 27;
+            byte copyValue2 = 100;
+
+            copyFrom.WriteByte(copyValue1);
+            copyFrom.WriteByte(copyValue2);
+
+            inStream.CopyFrom(copyFrom, 2);
+
+            BitStream outStream = new BitStream(inStream.ToArray());
+
+            Assert.That(outStream.ReadByte(), Is.EqualTo(initialValue1));
+            Assert.That(outStream.ReadByte(), Is.EqualTo(initialValue2));
+            Assert.That(outStream.ReadByte(), Is.EqualTo(copyValue1));
+            Assert.That(outStream.ReadByte(), Is.EqualTo(copyValue2));
+        }
+
+        [Test]
+        public void TestToArray()
+        {
+            BitStream inStream = new BitStream();
+            inStream.WriteByte(5);
+            inStream.WriteByte(6);
+            Assert.That(inStream.ToArray().Length, Is.EqualTo(2));
+        }
+
+
         [Test]
         public void TestInOutBytes()
         {

MLAPI/NetworkingManagerComponents/Binary/BitStream.cs

@@ -11,14 +11,15 @@ namespace MLAPI.NetworkingManagerComponents.Binary
     public sealed class BitStream : Stream
     {
         const int initialCapacity = 16;
+        const float initialGrowthFactor = 2.0f;
         private byte[] target;
 
         /// <summary>
         /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
         /// </summary>
         /// <param name="capacity">Initial capacity of buffer in bytes.</param>
         /// <param name="growthFactor">Factor by which buffer should grow when necessary.</param>
-        public BitStream(int capacity = initialCapacity, float growthFactor = 2.0f)
+        public BitStream(int capacity, float growthFactor)
         {
             target = new byte[capacity];
             GrowthFactor = growthFactor;
@@ -29,7 +30,17 @@ public BitStream(int capacity = initialCapacity, float growthFactor = 2.0f)
         /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
         /// </summary>
         /// <param name="growthFactor">Factor by which buffer should grow when necessary.</param>
-        public BitStream(float growthFactor = 2.0f) : this(initialCapacity, growthFactor) { }
+        public BitStream(float growthFactor) : this(initialCapacity, growthFactor) { }
+        /// <summary>
+        /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
+        /// </summary>
+        /// <param name="capacity"></param>
+        public BitStream(int capacity) : this(capacity, initialGrowthFactor) { }
+
+        /// <summary>
+        /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
+        /// </summary>
+        public BitStream() : this(initialCapacity, initialGrowthFactor) { }
 
         /// <summary>
         /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
@@ -69,7 +80,7 @@ public BitStream(byte[] target)
         /// <summary>
         /// Whether or not data can be read from the stream.
         /// </summary>
-        public override bool CanRead => BitPosition < (ulong)target.LongLength;
+        public override bool CanRead => Position < target.LongLength;
 
         /// <summary>
         /// Whether or not seeking is supported by this stream. (Always true)
@@ -632,23 +643,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)
-            {
-                ulong bytes = b.BitLength >> 3;
-                Write(b.target, 0, (int)bytes);
-                if ((b.BitLength & 7) != 0) _WriteBits(b.target[bytes - 1], (int)(b.BitLength & 7));
-            }
+            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)
                     _WriteIntByte(read);
+                UpdateLength();
             }
-
-            UpdateLength();
         }
 
+        // TODO: Implement CopyFrom() for BitStream with bitCount parameter
+        
         /// <summary>
         /// Update length of data considered to be "written" to the stream.
         /// </summary>