From 02819f006b179c8a69db6ea8adef6e924a05459f Mon Sep 17 00:00:00 2001 From: Matt Nadareski Date: Thu, 18 Apr 2024 11:30:53 -0400 Subject: [PATCH] Add byte array and stream extensions tests; fix issues --- .../Extensions/ByteArrayExtensionsTests.cs | 213 ++++++++++++++++++ .../Extensions/StreamExtensionsTests.cs | 207 +++++++++++++++++ .../Extensions/ByteArrayExtensions.cs | 8 +- SabreTools.IO/Extensions/StreamExtensions.cs | 1 + 4 files changed, 424 insertions(+), 5 deletions(-) create mode 100644 SabreTools.IO.Test/Extensions/ByteArrayExtensionsTests.cs create mode 100644 SabreTools.IO.Test/Extensions/StreamExtensionsTests.cs diff --git a/SabreTools.IO.Test/Extensions/ByteArrayExtensionsTests.cs b/SabreTools.IO.Test/Extensions/ByteArrayExtensionsTests.cs new file mode 100644 index 0000000..1068976 --- /dev/null +++ b/SabreTools.IO.Test/Extensions/ByteArrayExtensionsTests.cs @@ -0,0 +1,213 @@ +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 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 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 + } +} \ No newline at end of file diff --git a/SabreTools.IO.Test/Extensions/StreamExtensionsTests.cs b/SabreTools.IO.Test/Extensions/StreamExtensionsTests.cs new file mode 100644 index 0000000..1e7e838 --- /dev/null +++ b/SabreTools.IO.Test/Extensions/StreamExtensionsTests.cs @@ -0,0 +1,207 @@ +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 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 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 + } +} \ No newline at end of file diff --git a/SabreTools.IO/Extensions/ByteArrayExtensions.cs b/SabreTools.IO/Extensions/ByteArrayExtensions.cs index 57019e5..37bf992 100644 --- a/SabreTools.IO/Extensions/ByteArrayExtensions.cs +++ b/SabreTools.IO/Extensions/ByteArrayExtensions.cs @@ -23,10 +23,7 @@ namespace SabreTools.IO.Extensions /// Read a UInt8 and increment the pointer to an array /// public static byte ReadByteValue(this byte[] content, ref int offset) - { - byte[] buffer = ReadToBuffer(content, ref offset, 1); - return buffer[0]; - } + => content.ReadByte(ref offset); /// /// Read a UInt8[] and increment the pointer to an array @@ -185,6 +182,7 @@ namespace SabreTools.IO.Extensions return new Guid(buffer); } + // TODO: Determine if the reverse reads are doing what are expected #if NET7_0_OR_GREATER /// /// Read a Int128 and increment the pointer to an array @@ -309,7 +307,7 @@ namespace SabreTools.IO.Extensions return []; // If there are not enough bytes - if (offset + length >= content.Length) + if (offset + length > content.Length) throw new System.IO.EndOfStreamException(nameof(content)); // Handle the general case, forcing a read of the correct length diff --git a/SabreTools.IO/Extensions/StreamExtensions.cs b/SabreTools.IO/Extensions/StreamExtensions.cs index 53532e2..e482f12 100644 --- a/SabreTools.IO/Extensions/StreamExtensions.cs +++ b/SabreTools.IO/Extensions/StreamExtensions.cs @@ -178,6 +178,7 @@ namespace SabreTools.IO.Extensions return new Guid(buffer); } + // TODO: Determine if the reverse reads are doing what are expected #if NET7_0_OR_GREATER /// /// Read a Int128 from the stream