Bump version

SabreTools.IO.Test/Extensions/BinaryReaderExtensionsTests.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using SabreTools.IO.Extensions;
+using Xunit;
+
+namespace SabreTools.IO.Test
+{
+    public class BinaryReaderExtensionsTests
+    {
+        private static readonly byte[] _bytes =
+        [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+            0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+        ];
+
+        [Fact]
+        public void ReadInt16BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var br = new BinaryReader(stream);
+            short read = br.ReadInt16BigEndian();
+            Assert.Equal(0x0001, read);
+        }
+
+        [Fact]
+        public void ReadUInt16BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var br = new BinaryReader(stream);
+            ushort read = br.ReadUInt16BigEndian();
+            Assert.Equal(0x0001, read);
+        }
+
+        [Fact]
+        public void ReadInt32BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var br = new BinaryReader(stream);
+            int read = br.ReadInt32BigEndian();
+            Assert.Equal(0x00010203, read);
+        }
+
+        [Fact]
+        public void ReadUInt32BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var br = new BinaryReader(stream);
+            uint read = br.ReadUInt32BigEndian();
+            Assert.Equal((uint)0x00010203, read);
+        }
+
+        [Fact]
+        public void ReadInt64BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var br = new BinaryReader(stream);
+            long read = br.ReadInt64BigEndian();
+            Assert.Equal(0x0001020304050607, read);
+        }
+
+        [Fact]
+        public void ReadUInt64BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var br = new BinaryReader(stream);
+            ulong read = br.ReadUInt64BigEndian();
+            Assert.Equal((ulong)0x0001020304050607, read);
+        }
+
+        // TODO: Add byte[], char[] tests
+        // TODO: Add float, double tests
+        // TODO: Add string reading tests
+    }
+}

SabreTools.IO.Test/Extensions/ByteArrayExtensionsTests.cs

@@ -0,0 +1,249 @@
+using System;
+using System.Linq;
+using SabreTools.IO.Extensions;
+using Xunit;
+
+namespace SabreTools.IO.Test
+{
+    public class ByteArrayExtensionsTests
+    {
+        private static readonly byte[] _bytes =
+        [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+            0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+        ];
+
+        [Fact]
+        public void ReadByteTest()
+        {
+            int offset = 0;
+            byte read = _bytes.ReadByte(ref offset);
+            Assert.Equal(0x00, read);
+        }
+
+        [Fact]
+        public void ReadByteValueTest()
+        {
+            int offset = 0;
+            byte read = _bytes.ReadByteValue(ref offset);
+            Assert.Equal(0x00, read);
+        }
+
+        [Fact]
+        public void ReadBytesTest()
+        {
+            int offset = 0, length = 4;
+            byte[] read = _bytes.ReadBytes(ref offset, length);
+            Assert.Equal(length, read.Length);
+            Assert.True(read.SequenceEqual(_bytes.Take(length)));
+        }
+
+        [Fact]
+        public void ReadSByteTest()
+        {
+            int offset = 0;
+            sbyte read = _bytes.ReadSByte(ref offset);
+            Assert.Equal(0x00, read);
+        }
+
+        [Fact]
+        public void ReadCharTest()
+        {
+            int offset = 0;
+            char read = _bytes.ReadChar(ref offset);
+            Assert.Equal('\0', read);
+        }
+
+        [Fact]
+        public void ReadInt16Test()
+        {
+            int offset = 0;
+            short read = _bytes.ReadInt16(ref offset);
+            Assert.Equal(0x0100, read);
+        }
+
+        [Fact]
+        public void ReadInt16BigEndianTest()
+        {
+            int offset = 0;
+            short read = _bytes.ReadInt16BigEndian(ref offset);
+            Assert.Equal(0x0001, read);
+        }
+
+        [Fact]
+        public void ReadUInt16Test()
+        {
+            int offset = 0;
+            ushort read = _bytes.ReadUInt16(ref offset);
+            Assert.Equal(0x0100, read);
+        }
+
+        [Fact]
+        public void ReadUInt16BigEndianTest()
+        {
+            int offset = 0;
+            ushort read = _bytes.ReadUInt16BigEndian(ref offset);
+            Assert.Equal(0x0001, read);
+        }
+
+        [Fact]
+        public void ReadInt32Test()
+        {
+            int offset = 0;
+            int read = _bytes.ReadInt32(ref offset);
+            Assert.Equal(0x03020100, read);
+        }
+
+        [Fact]
+        public void ReadInt32BigEndianTest()
+        {
+            int offset = 0;
+            int read = _bytes.ReadInt32BigEndian(ref offset);
+            Assert.Equal(0x00010203, read);
+        }
+
+        [Fact]
+        public void ReadUInt32Test()
+        {
+            int offset = 0;
+            uint read = _bytes.ReadUInt32(ref offset);
+            Assert.Equal((uint)0x03020100, read);
+        }
+
+        [Fact]
+        public void ReadUInt32BigEndianTest()
+        {
+            int offset = 0;
+            uint read = _bytes.ReadUInt32BigEndian(ref offset);
+            Assert.Equal((uint)0x00010203, read);
+        }
+
+        [Fact]
+        public void ReadSingleTest()
+        {
+            int offset = 0;
+            float expected = BitConverter.Int32BitsToSingle(0x03020100);
+            float read = _bytes.ReadSingle(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadSingleBigEndianTest()
+        {
+            int offset = 0;
+            float expected = BitConverter.Int32BitsToSingle(0x00010203);
+            float read = _bytes.ReadSingleBigEndian(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadInt64Test()
+        {
+            int offset = 0;
+            long read = _bytes.ReadInt64(ref offset);
+            Assert.Equal(0x0706050403020100, read);
+        }
+
+        [Fact]
+        public void ReadInt64BigEndianTest()
+        {
+            int offset = 0;
+            long read = _bytes.ReadInt64BigEndian(ref offset);
+            Assert.Equal(0x0001020304050607, read);
+        }
+
+        [Fact]
+        public void ReadUInt64Test()
+        {
+            int offset = 0;
+            ulong read = _bytes.ReadUInt64(ref offset);
+            Assert.Equal((ulong)0x0706050403020100, read);
+        }
+
+        [Fact]
+        public void ReadUInt64BigEndianTest()
+        {
+            int offset = 0;
+            ulong read = _bytes.ReadUInt64BigEndian(ref offset);
+            Assert.Equal((ulong)0x0001020304050607, read);
+        }
+
+        [Fact]
+        public void ReadDoubleTest()
+        {
+            int offset = 0;
+            double expected = BitConverter.Int64BitsToDouble(0x0706050403020100);
+            double read = _bytes.ReadDouble(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadDoubleBigEndianTest()
+        {
+            int offset = 0;
+            double expected = BitConverter.Int64BitsToDouble(0x0001020304050607);
+            double read = _bytes.ReadDoubleBigEndian(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadGuidTest()
+        {
+            int offset = 0;
+            var expected = new Guid(_bytes);
+            Guid read = _bytes.ReadGuid(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadGuidBigEndian()
+        {
+            int offset = 0;
+            var expected = new Guid(_bytes.Reverse().ToArray());
+            Guid read = _bytes.ReadGuidBigEndian(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+#if NET7_0_OR_GREATER
+        [Fact]
+        public void ReadInt128Test()
+        {
+            int offset = 0;
+            var expected = new Int128(BitConverter.ToUInt64(_bytes, 0), BitConverter.ToUInt64(_bytes, 8));
+            Int128 read = _bytes.ReadInt128(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadInt128BigEndianTest()
+        {
+            int offset = 0;
+            var reversed = _bytes.Reverse().ToArray();
+            var expected = new Int128(BitConverter.ToUInt64(reversed, 0), BitConverter.ToUInt64(reversed, 8));
+            Int128 read = _bytes.ReadInt128BigEndian(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadUInt128Test()
+        {
+            int offset = 0;
+            var expected = new UInt128(BitConverter.ToUInt64(_bytes, 0), BitConverter.ToUInt64(_bytes, 8));
+            UInt128 read = _bytes.ReadUInt128(ref offset);
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadUInt128BigEndianTest()
+        {
+            int offset = 0;
+            var reversed = _bytes.Reverse().ToArray();
+            var expected = new UInt128(BitConverter.ToUInt64(reversed, 0), BitConverter.ToUInt64(reversed, 8));
+            UInt128 read = _bytes.ReadUInt128BigEndian(ref offset);
+            Assert.Equal(expected, read);
+        }
+#endif
+
+        // TODO: Add string reading tests
+    }
+}

SabreTools.IO.Test/Extensions/StreamExtensionsTests.cs

@@ -0,0 +1,243 @@
+using System;
+using System.IO;
+using System.Linq;
+using SabreTools.IO.Extensions;
+using Xunit;
+
+namespace SabreTools.IO.Test
+{
+    public class StreamExtensionsTests
+    {
+        private static readonly byte[] _bytes =
+        [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+            0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+        ];
+
+        [Fact]
+        public void ReadByteValueTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            byte read = stream.ReadByteValue();
+            Assert.Equal(0x00, read);
+        }
+
+        [Fact]
+        public void ReadBytesTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            int length = 4;
+            byte[] read = stream.ReadBytes(length);
+            Assert.Equal(length, read.Length);
+            Assert.True(read.SequenceEqual(_bytes.Take(length)));
+        }
+
+        [Fact]
+        public void ReadSByteTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            sbyte read = stream.ReadSByte();
+            Assert.Equal(0x00, read);
+        }
+
+        [Fact]
+        public void ReadCharTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            char read = stream.ReadChar();
+            Assert.Equal('\0', read);
+        }
+
+        [Fact]
+        public void ReadInt16Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            short read = stream.ReadInt16();
+            Assert.Equal(0x0100, read);
+        }
+
+        [Fact]
+        public void ReadInt16BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            short read = stream.ReadInt16BigEndian();
+            Assert.Equal(0x0001, read);
+        }
+
+        [Fact]
+        public void ReadUInt16Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            ushort read = stream.ReadUInt16();
+            Assert.Equal(0x0100, read);
+        }
+
+        [Fact]
+        public void ReadUInt16BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            ushort read = stream.ReadUInt16BigEndian();
+            Assert.Equal(0x0001, read);
+        }
+
+        [Fact]
+        public void ReadInt32Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            int read = stream.ReadInt32();
+            Assert.Equal(0x03020100, read);
+        }
+
+        [Fact]
+        public void ReadInt32BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            int read = stream.ReadInt32BigEndian();
+            Assert.Equal(0x00010203, read);
+        }
+
+        [Fact]
+        public void ReadUInt32Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            uint read = stream.ReadUInt32();
+            Assert.Equal((uint)0x03020100, read);
+        }
+
+        [Fact]
+        public void ReadUInt32BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            uint read = stream.ReadUInt32BigEndian();
+            Assert.Equal((uint)0x00010203, read);
+        }
+
+        [Fact]
+        public void ReadSingleTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            float expected = BitConverter.Int32BitsToSingle(0x03020100);
+            float read = stream.ReadSingle();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadSingleBigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            float expected = BitConverter.Int32BitsToSingle(0x00010203);
+            float read = stream.ReadSingleBigEndian();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadInt64Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            long read = stream.ReadInt64();
+            Assert.Equal(0x0706050403020100, read);
+        }
+
+        [Fact]
+        public void ReadInt64BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            long read = stream.ReadInt64BigEndian();
+            Assert.Equal(0x0001020304050607, read);
+        }
+
+        [Fact]
+        public void ReadUInt64Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            ulong read = stream.ReadUInt64();
+            Assert.Equal((ulong)0x0706050403020100, read);
+        }
+
+        [Fact]
+        public void ReadUInt64BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            ulong read = stream.ReadUInt64BigEndian();
+            Assert.Equal((ulong)0x0001020304050607, read);
+        }
+
+        [Fact]
+        public void ReadDoubleTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            double expected = BitConverter.Int64BitsToDouble(0x0706050403020100);
+            double read = stream.ReadDouble();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadDoubleBigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            double expected = BitConverter.Int64BitsToDouble(0x0001020304050607);
+            double read = stream.ReadDoubleBigEndian();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadGuidTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var expected = new Guid(_bytes);
+            Guid read = stream.ReadGuid();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadGuidBigEndian()
+        {
+            var stream = new MemoryStream(_bytes);
+            var expected = new Guid(_bytes.Reverse().ToArray());
+            Guid read = stream.ReadGuidBigEndian();
+            Assert.Equal(expected, read);
+        }
+
+#if NET7_0_OR_GREATER
+        [Fact]
+        public void ReadInt128Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            var expected = new Int128(BitConverter.ToUInt64(_bytes, 0), BitConverter.ToUInt64(_bytes, 8));
+            Int128 read = stream.ReadInt128();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadInt128BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var reversed = _bytes.Reverse().ToArray();
+            var expected = new Int128(BitConverter.ToUInt64(reversed, 0), BitConverter.ToUInt64(reversed, 8));
+            Int128 read = stream.ReadInt128BigEndian();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadUInt128Test()
+        {
+            var stream = new MemoryStream(_bytes);
+            var expected = new UInt128(BitConverter.ToUInt64(_bytes, 0), BitConverter.ToUInt64(_bytes, 8));
+            UInt128 read = stream.ReadUInt128();
+            Assert.Equal(expected, read);
+        }
+
+        [Fact]
+        public void ReadUInt128BigEndianTest()
+        {
+            var stream = new MemoryStream(_bytes);
+            var reversed = _bytes.Reverse().ToArray();
+            var expected = new UInt128(BitConverter.ToUInt64(reversed, 0), BitConverter.ToUInt64(reversed, 8));
+            UInt128 read = stream.ReadUInt128BigEndian();
+            Assert.Equal(expected, read);
+        }
+#endif
+
+        // TODO: Add string reading tests
+    }
+}

SabreTools.IO.Test/Streams/ReadOnlyCompositeStreamTests.cs

@@ -79,7 +79,9 @@ namespace SabreTools.IO.Test.Streams
             var stream = new ReadOnlyCompositeStream();
 
             byte[] buf = new byte[512];
-            Assert.Throws<ArgumentOutOfRangeException>(() => stream.Read(buf, 0, 512));
+            int read = stream.Read(buf, 0, 512);
+
+            Assert.Equal(0, read);
         }
 
         [Fact]

SabreTools.IO/Extensions/BinaryReaderExtensions.cs

@@ -8,13 +8,8 @@ namespace SabreTools.IO.Extensions
     /// </summary>
     public static class BinaryReaderExtensions
     {
-        /// <summary>
-        /// Reads the specified number of bytes from the stream, starting from a specified point in the byte array.
-        /// </summary>
-        /// <param name="buffer">The buffer to read data into.</param>
-        /// <param name="index">The starting point in the buffer at which to begin reading into the buffer.</param>
-        /// <param name="count">The number of bytes to read.</param>
-        /// <returns>The number of bytes read into buffer. This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached.</returns>
+        /// <inheritdoc cref="BinaryReader.Read(byte[], int, int)"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static int ReadBigEndian(this BinaryReader reader, byte[] buffer, int index, int count)
         {
             int retval = reader.Read(buffer, index, count);
@@ -22,13 +17,8 @@ namespace SabreTools.IO.Extensions
             return retval;
         }
 
-        /// <summary>
-        /// Reads the specified number of characters from the stream, starting from a specified point in the character array.
-        /// </summary>
-        /// <param name="buffer">The buffer to read data into.</param>
-        /// <param name="index">The starting point in the buffer at which to begin reading into the buffer.</param>
-        /// <param name="count">The number of characters to read.</param>
-        /// <returns>The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached.</returns>
+        /// <inheritdoc cref="BinaryReader.Read(char[], int, int)"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static int ReadBigEndian(this BinaryReader reader, char[] buffer, int index, int count)
         {
             int retval = reader.Read(buffer, index, count);
@@ -36,11 +26,8 @@ namespace SabreTools.IO.Extensions
             return retval;
         }
 
-        /// <summary>
-        /// Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes.
-        /// </summary>
-        /// <param name="count">The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur.</param>
-        /// <returns>A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadBytes(int)"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static byte[] ReadBytesBigEndian(this BinaryReader reader, int count)
         {
             byte[] retval = reader.ReadBytes(count);
@@ -48,11 +35,8 @@ namespace SabreTools.IO.Extensions
             return retval;
         }
 
-        /// <summary>
-        /// Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream.
-        /// </summary>
-        /// <param name="count">The number of characters to read. This value must be 0 or a non-negative number or an exception will occur.</param>
-        /// <returns>A character array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadChars(int)"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static char[] ReadCharsBigEndian(this BinaryReader reader, int count)
         {
             char[] retval = reader.ReadChars(count);
@@ -60,10 +44,8 @@ namespace SabreTools.IO.Extensions
             return retval;
         }
 
-        /// <summary>
-        /// Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes.
-        /// </summary>
-        /// <returns>A decimal value read from the current stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadDecimal"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static decimal ReadDecimalBigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(16);
@@ -77,10 +59,8 @@ namespace SabreTools.IO.Extensions
             return new decimal([i1, i2, i3, i4]);
         }
 
-        /// <summary>
-        /// eads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes.
-        /// </summary>
-        /// <returns>An 8-byte floating point value read from the current stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadDouble"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static double ReadDoubleBigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(8);
@@ -88,10 +68,8 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToDouble(retval, 0);
         }
 
-        /// <summary>
-        /// Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes.
-        /// </summary>
-        /// <returns>A 2-byte signed integer read from the current stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadInt16"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static short ReadInt16BigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(2);
@@ -99,10 +77,8 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToInt16(retval, 0);
         }
 
-        /// <summary>
-        /// Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes.
-        /// </summary>
-        /// <returns>A 4-byte signed integer read from the current stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadInt32"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static int ReadInt32BigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(4);
@@ -110,10 +86,8 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToInt32(retval, 0);
         }
 
-        /// <summary>
-        /// Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes.
-        /// </summary>
-        /// <returns>An 8-byte signed integer read from the current stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadInt64"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static long ReadInt64BigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(8);
@@ -121,10 +95,8 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToInt64(retval, 0);
         }
 
-        /// <summary>
-        /// Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes.
-        /// </summary>
-        /// <returns>A 4-byte floating point value read from the current stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadSingle"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static float ReadSingleBigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(4);
@@ -132,12 +104,8 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToSingle(retval, 0);
         }
 
-        /// <summary>
-        /// Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes.
-        /// 
-        /// This API is not CLS-compliant.
-        /// </summary>
-        /// <returns>A 2-byte unsigned integer read from this stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadUInt16"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static ushort ReadUInt16BigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(2);
@@ -145,12 +113,7 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToUInt16(retval, 0);
         }
 
-        /// <summary>
-        /// Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes.
-        /// 
-        /// This API is not CLS-compliant.
-        /// </summary>
-        /// <returns>A 4-byte unsigned integer read from this stream.</returns>
+        /// <remarks>Reads in big-endian format</remarks>
         public static uint ReadUInt32BigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(4);
@@ -158,12 +121,8 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToUInt32(retval, 0);
         }
 
-        /// <summary>
-        /// Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes.
-        /// 
-        /// This API is not CLS-compliant.
-        /// </summary>
-        /// <returns>An 8-byte unsigned integer read from this stream.</returns>
+        /// <inheritdoc cref="BinaryReader.ReadUInt64"/>
+        /// <remarks>Reads in big-endian format</remarks>
         public static ulong ReadUInt64BigEndian(this BinaryReader reader)
         {
             byte[] retval = reader.ReadBytes(8);

SabreTools.IO/Extensions/ByteArrayExtensions.cs

@@ -15,51 +15,28 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static byte ReadByte(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 1);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 1);
             return buffer[0];
         }
 
         /// <summary>
-        /// Read a UInt8[] and increment the pointer to an array
+        /// Read a UInt8 and increment the pointer to an array
         /// </summary>
-        public static byte[]? ReadBytes(this byte[]? content, ref int offset, int count)
-        {
-            // If the byte array is invalid, don't do anything
-            if (content == null)
-                return null;
-
-            // If there's an invalid byte count, don't do anything
-            if (count <= 0 || offset >= content.Length)
-                return null;
-
-            // Allocate enough space for the data requested
-            byte[] buffer = new byte[count];
-
-            // If we have less data left than requested, only read until the end
-            if (offset + count >= content.Length)
-                count = content.Length - offset;
-
-            // If we have a non-zero count, copy the data into the array
-            if (count > 0)
-                Array.Copy(content, offset, buffer, 0, Math.Min(count, content.Length - offset));
-
-            // Increment the offset and return
-            offset += count;
-            return buffer;
-        }
+        public static byte ReadByteValue(this byte[] content, ref int offset)
+            => content.ReadByte(ref offset);
 
         /// <summary>
-        /// Read a Int8 and increment the pointer to an array
+        /// Read a UInt8[] and increment the pointer to an array
+        /// </summary>
+        public static byte[] ReadBytes(this byte[] content, ref int offset, int count)
+            => ReadToBuffer(content, ref offset, count);
+
+        /// <summary>
+        /// Read an Int8 and increment the pointer to an array
         /// </summary>
         public static sbyte ReadSByte(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 1);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 1);
             return (sbyte)buffer[0];
         }
 
@@ -68,34 +45,25 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static char ReadChar(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 1);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 1);
             return (char)buffer[0];
         }
 
         /// <summary>
-        /// Read a Int16 and increment the pointer to an array
+        /// Read an Int16 and increment the pointer to an array
         /// </summary>
         public static short ReadInt16(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 2);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 2);
             return BitConverter.ToInt16(buffer, 0);
         }
 
         /// <summary>
-        /// Read a Int16 in big-endian format and increment the pointer to an array
+        /// Read an Int16 in big-endian format and increment the pointer to an array
         /// </summary>
         public static short ReadInt16BigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 2);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 2);
             Array.Reverse(buffer);
             return BitConverter.ToInt16(buffer, 0);
         }
@@ -105,10 +73,7 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static ushort ReadUInt16(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 2);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 2);
             return BitConverter.ToUInt16(buffer, 0);
         }
 
@@ -117,35 +82,26 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static ushort ReadUInt16BigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 2);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 2);
             Array.Reverse(buffer);
             return BitConverter.ToUInt16(buffer, 0);
         }
 
         /// <summary>
-        /// Read a Int32 and increment the pointer to an array
+        /// Read an Int32 and increment the pointer to an array
         /// </summary>
         public static int ReadInt32(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 4);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 4);
             return BitConverter.ToInt32(buffer, 0);
         }
 
         /// <summary>
-        /// Read a Int32 in big-endian format and increment the pointer to an array
+        /// Read an Int32 in big-endian format and increment the pointer to an array
         /// </summary>
         public static int ReadInt32BigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 4);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 4);
             Array.Reverse(buffer);
             return BitConverter.ToInt32(buffer, 0);
         }
@@ -155,10 +111,7 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static uint ReadUInt32(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 4);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 4);
             return BitConverter.ToUInt32(buffer, 0);
         }
 
@@ -167,35 +120,45 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static uint ReadUInt32BigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 4);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 4);
             Array.Reverse(buffer);
             return BitConverter.ToUInt32(buffer, 0);
         }
 
         /// <summary>
-        /// Read a Int64 and increment the pointer to an array
+        /// Read a Single and increment the pointer to an array
+        /// </summary>
+        public static float ReadSingle(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 4);
+            return BitConverter.ToSingle(buffer, 0);
+        }
+
+        /// <summary>
+        /// Read a Single in big-endian format and increment the pointer to an array
+        /// </summary>
+        public static float ReadSingleBigEndian(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 4);
+            Array.Reverse(buffer);
+            return BitConverter.ToSingle(buffer, 0);
+        }
+
+        /// <summary>
+        /// Read an Int64 and increment the pointer to an array
         /// </summary>
         public static long ReadInt64(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 8);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 8);
             return BitConverter.ToInt64(buffer, 0);
         }
 
         /// <summary>
-        /// Read a Int64 in big-endian format and increment the pointer to an array
+        /// Read an Int64 in big-endian format and increment the pointer to an array
         /// </summary>
         public static long ReadInt64BigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 8);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 8);
             Array.Reverse(buffer);
             return BitConverter.ToInt64(buffer, 0);
         }
@@ -205,10 +168,7 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static ulong ReadUInt64(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 8);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 8);
             return BitConverter.ToUInt64(buffer, 0);
         }
 
@@ -217,23 +177,36 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static ulong ReadUInt64BigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 8);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 8);
             Array.Reverse(buffer);
             return BitConverter.ToUInt64(buffer, 0);
         }
 
+        /// <summary>
+        /// Read a Double and increment the pointer to an array
+        /// </summary>
+        public static double ReadDouble(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 8);
+            return BitConverter.ToDouble(buffer, 0);
+        }
+
+        /// <summary>
+        /// Read a Double in big-endian format and increment the pointer to an array
+        /// </summary>
+        public static double ReadDoubleBigEndian(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 8);
+            Array.Reverse(buffer);
+            return BitConverter.ToDouble(buffer, 0);
+        }
+
         /// <summary>
         /// Read a Guid and increment the pointer to an array
         /// </summary>
         public static Guid ReadGuid(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 16);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 16);
             return new Guid(buffer);
         }
 
@@ -242,28 +215,67 @@ namespace SabreTools.IO.Extensions
         /// </summary>
         public static Guid ReadGuidBigEndian(this byte[] content, ref int offset)
         {
-            byte[]? buffer = content.ReadBytes(ref offset, 16);
-            if (buffer == null)
-                return default;
-
+            byte[] buffer = ReadToBuffer(content, ref offset, 16);
             Array.Reverse(buffer);
             return new Guid(buffer);
         }
 
+        // TODO: Determine if the reverse reads are doing what are expected
+#if NET7_0_OR_GREATER
         /// <summary>
-        /// Read a null-terminated string from the stream
+        /// Read an Int128 and increment the pointer to an array
         /// </summary>
-        public static string? ReadString(this byte[] content, ref int offset) => content.ReadString(ref offset, Encoding.Default);
+        public static Int128 ReadInt128(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 16);
+            return new Int128(BitConverter.ToUInt64(buffer, 0), BitConverter.ToUInt64(buffer, 8));
+        }
 
         /// <summary>
-        /// Read a null-terminated string from the stream
+        /// Read an Int128 in big-endian format and increment the pointer to an array
+        /// </summary>
+        public static Int128 ReadInt128BigEndian(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 16);
+            Array.Reverse(buffer);
+            return new Int128(BitConverter.ToUInt64(buffer, 0), BitConverter.ToUInt64(buffer, 8));
+        }
+
+        /// <summary>
+        /// Read a UInt128 and increment the pointer to an array
+        /// </summary>
+        public static UInt128 ReadUInt128(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 16);
+            return new UInt128(BitConverter.ToUInt64(buffer, 0), BitConverter.ToUInt64(buffer, 8));
+        }
+
+        /// <summary>
+        /// Read a UInt128 in big-endian format and increment the pointer to an array
+        /// </summary>
+        public static UInt128 ReadUInt128BigEndian(this byte[] content, ref int offset)
+        {
+            byte[] buffer = ReadToBuffer(content, ref offset, 16);
+            Array.Reverse(buffer);
+            return new UInt128(BitConverter.ToUInt64(buffer, 0), BitConverter.ToUInt64(buffer, 8));
+        }
+#endif
+
+        /// <summary>
+        /// Read a null-terminated string from the byte array
+        /// </summary>
+        public static string? ReadString(this byte[] content, ref int offset)
+            => content.ReadString(ref offset, Encoding.Default);
+
+        /// <summary>
+        /// Read a null-terminated string from the byte array
         /// </summary>
         public static string? ReadString(this byte[] content, ref int offset, Encoding encoding)
         {
             if (offset >= content.Length)
                 return null;
 
-            byte[] nullTerminator = encoding.GetBytes(new char[] { '\0' });
+            byte[] nullTerminator = encoding.GetBytes("\0");
             int charWidth = nullTerminator.Length;
 
             var keyChars = new List<char>();
@@ -279,5 +291,69 @@ namespace SabreTools.IO.Extensions
 
             return new string([.. keyChars]).TrimEnd('\0');
         }
+
+        /// <summary>
+        /// Read a string that is terminated by a newline but contains a quoted portion that
+        /// may also contain a newline from the stream
+        /// </summary>
+        public static string? ReadQuotedString(this byte[] content, ref int offset)
+            => content.ReadQuotedString(ref offset, Encoding.Default);
+
+        /// <summary>
+        /// Read a string that is terminated by a newline but contains a quoted portion that
+        /// may also contain a newline from the stream
+        /// </summary>
+        public static string? ReadQuotedString(this byte[] content, ref int offset, Encoding encoding)
+        {
+            if (offset >= content.Length)
+                return null;
+
+            byte[] nullTerminator = encoding.GetBytes("\0");
+            int charWidth = nullTerminator.Length;
+
+            var keyChars = new List<char>();
+            bool openQuote = false;
+            while (offset < content.Length)
+            {
+                char c = encoding.GetChars(content, offset, charWidth)[0];
+                keyChars.Add(c);
+                offset += charWidth;
+
+                // If we have a quote, flip the flag
+                if (c == '"')
+                    openQuote = !openQuote;
+
+                // If we have a newline not in a quoted string, exit the loop
+                else if (c == (byte)'\n' && !openQuote)
+                    break;
+            }
+
+            return new string([.. keyChars]).TrimEnd();
+        }
+
+        /// <summary>
+        /// Read a number of bytes from the current byte array to a buffer
+        /// </summary>
+        private static byte[] ReadToBuffer(byte[] content, ref int offset, int length)
+        {
+            // If we have an invalid length
+            if (length < 0)
+                throw new ArgumentOutOfRangeException($"{nameof(length)} must be 0 or a positive value");
+
+            // Handle the 0-byte case
+            if (length == 0)
+                return [];
+
+            // If there are not enough bytes
+            if (offset + length > content.Length)
+                throw new System.IO.EndOfStreamException(nameof(content));
+
+            // Handle the general case, forcing a read of the correct length
+            byte[] buffer = new byte[length];
+            Array.Copy(content, offset, buffer, 0, length);
+            offset += length;
+
+            return buffer;
+        }
     }
 }

SabreTools.IO/Extensions/StreamExtensions.cs

@@ -28,7 +28,7 @@ namespace SabreTools.IO.Extensions
             => ReadToBuffer(stream, count);
 
         /// <summary>
-        /// Read a Int8 from the stream
+        /// Read an Int8 from the stream
         /// </summary>
         public static sbyte ReadSByte(this Stream stream)
         {
@@ -46,7 +46,7 @@ namespace SabreTools.IO.Extensions
         }
 
         /// <summary>
-        /// Read a Int16 from the stream
+        /// Read an Int16 from the stream
         /// </summary>
         public static short ReadInt16(this Stream stream)
         {
@@ -55,7 +55,7 @@ namespace SabreTools.IO.Extensions
         }
 
         /// <summary>
-        /// Read a Int16 from the stream in big-endian format
+        /// Read an Int16 from the stream in big-endian format
         /// </summary>
         public static short ReadInt16BigEndian(this Stream stream)
         {
@@ -122,7 +122,26 @@ namespace SabreTools.IO.Extensions
         }
 
         /// <summary>
-        /// Read a Int64 from the stream
+        /// Read a Single from the stream
+        /// </summary>
+        public static float ReadSingle(this Stream stream)
+        {
+            byte[] buffer = ReadToBuffer(stream, 4);
+            return BitConverter.ToSingle(buffer, 0);
+        }
+
+        /// <summary>
+        /// Read a Single from the stream in big-endian format
+        /// </summary>
+        public static float ReadSingleBigEndian(this Stream stream)
+        {
+            byte[] buffer = ReadToBuffer(stream, 4);
+            Array.Reverse(buffer);
+            return BitConverter.ToSingle(buffer, 0);
+        }
+
+        /// <summary>
+        /// Read an Int64 from the stream
         /// </summary>
         public static long ReadInt64(this Stream stream)
         {
@@ -131,7 +150,7 @@ namespace SabreTools.IO.Extensions
         }
 
         /// <summary>
-        /// Read a Int64 from the stream in big-endian format
+        /// Read an Int64 from the stream in big-endian format
         /// </summary>
         public static long ReadInt64BigEndian(this Stream stream)
         {
@@ -159,6 +178,25 @@ namespace SabreTools.IO.Extensions
             return BitConverter.ToUInt64(buffer, 0);
         }
 
+        /// <summary>
+        /// Read a Double from the stream
+        /// </summary>
+        public static double ReadDouble(this Stream stream)
+        {
+            byte[] buffer = ReadToBuffer(stream, 8);
+            return BitConverter.ToDouble(buffer, 0);
+        }
+
+        /// <summary>
+        /// Read a Double from the stream in big-endian format
+        /// </summary>
+        public static double ReadDoubleBigEndian(this Stream stream)
+        {
+            byte[] buffer = ReadToBuffer(stream, 8);
+            Array.Reverse(buffer);
+            return BitConverter.ToDouble(buffer, 0);
+        }
+
         /// <summary>
         /// Read a Guid from the stream
         /// </summary>
@@ -178,9 +216,10 @@ namespace SabreTools.IO.Extensions
             return new Guid(buffer);
         }
 
+        // TODO: Determine if the reverse reads are doing what are expected
 #if NET7_0_OR_GREATER
         /// <summary>
-        /// Read a Int128 from the stream
+        /// Read an Int128 from the stream
         /// </summary>
         public static Int128 ReadInt128(this Stream stream)
         {
@@ -189,7 +228,7 @@ namespace SabreTools.IO.Extensions
         }
 
         /// <summary>
-        /// Read a Int128 from the stream in big-endian format
+        /// Read an Int128 from the stream in big-endian format
         /// </summary>
         public static Int128 ReadInt128BigEndian(this Stream stream)
         {

SabreTools.IO/SabreTools.IO.csproj

@@ -7,7 +7,7 @@
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>1.3.5</Version>
+    <Version>1.3.7</Version>
 
     <!-- Package Properties -->
     <Authors>Matt Nadareski</Authors>

SabreTools.IO/Streams/ReadOnlyCompositeStream.cs

@@ -148,9 +148,9 @@ namespace SabreTools.IO.Streams
         public override int Read(byte[] buffer, int offset, int count)
         {
             // Determine which stream we start reading from
-            (int streamIndex, long streamOffset) = DetermineStreamIndex(offset);
+            (int streamIndex, long streamOffset) = DetermineStreamIndex(_position);
             if (streamIndex == -1)
-                throw new ArgumentOutOfRangeException(nameof(offset));
+                return 0;
 
             // Determine if the stream fully contains the requested segment
             bool singleStream = StreamContains(streamIndex, streamOffset, count);
@@ -228,7 +228,7 @@ namespace SabreTools.IO.Streams
         /// Determine the index of the stream that contains a particular offset
         /// </summary>
         /// <returns>Index of the stream containing the offset and the real offset in the stream, (-1, -1) on error</returns>
-        private (int index, long realOffset) DetermineStreamIndex(int offset)
+        private (int index, long realOffset) DetermineStreamIndex(long offset)
         {
             // If the offset is out of bounds
             if (offset < 0 || offset >= _length)