test: 100% coverage on stream Read/Write methods

X10D.Tests/src/IO/StreamTests.ReadDecimal.cs

@@ -0,0 +1,73 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.IO;
+
+namespace X10D.Tests.IO;
+
+public partial class StreamTests
+{
+    [TestMethod]
+    public void ReadDecimal_ShouldThrowArgumentException_GivenNonReadableStream()
+    {
+        Stream stream = new DummyStream();
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadDecimal());
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadDecimal(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadDecimal(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadDecimal_ShouldThrowArgumentNullException_GivenNullStream()
+    {
+        Stream stream = null!;
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadDecimal());
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadDecimal(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadDecimal(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadDecimal_ShouldThrowArgumentOutOfRangeException_GivenInvalidEndiannessValue()
+    {
+        // we don't need to enclose this stream in a using declaration, since disposing a
+        // null stream is meaningless. NullStream.Dispose actually does nothing, anyway.
+        // that - coupled with the fact that encapsulating the stream in a using declaration causes the
+        // analyser to trip up and think the stream is disposed by the time the local is captured in
+        // assertion lambda - means this line is fine as it is. please do not change.
+        Stream stream = Stream.Null;
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => stream.ReadDecimal((Endianness)(-1)));
+    }
+
+    [TestMethod]
+    public void ReadDecimal_ShouldReadBigEndian_GivenBigEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[]
+        {
+            0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x68
+        };
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const decimal expected = 420.0m;
+        decimal actual = stream.ReadDecimal(Endianness.BigEndian);
+
+        Assert.AreEqual(16, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [TestMethod]
+    public void ReadDecimal_ShouldWriteLittleEndian_GivenLittleEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[]
+        {
+            0x68, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00
+        };
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const decimal expected = 420.0m;
+        decimal actual = stream.ReadDecimal(Endianness.LittleEndian);
+
+        Assert.AreEqual(16, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+}

X10D.Tests/src/IO/StreamTests.ReadDouble.cs

@@ -0,0 +1,67 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.IO;
+
+namespace X10D.Tests.IO;
+
+public partial class StreamTests
+{
+    [TestMethod]
+    public void ReadDouble_ShouldThrowArgumentException_GivenNonReadableStream()
+    {
+        Stream stream = new DummyStream();
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadDouble());
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadDouble(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadDouble(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadDouble_ShouldThrowArgumentNullException_GivenNullStream()
+    {
+        Stream stream = null!;
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadDouble());
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadDouble(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadDouble(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadDouble_ShouldThrowArgumentOutOfRangeException_GivenInvalidEndiannessValue()
+    {
+        // we don't need to enclose this stream in a using declaration, since disposing a
+        // null stream is meaningless. NullStream.Dispose actually does nothing, anyway.
+        // that - coupled with the fact that encapsulating the stream in a using declaration causes the
+        // analyser to trip up and think the stream is disposed by the time the local is captured in
+        // assertion lambda - means this line is fine as it is. please do not change.
+        Stream stream = Stream.Null;
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => stream.ReadDouble((Endianness)(-1)));
+    }
+
+    [TestMethod]
+    public void ReadDouble_ShouldReadBigEndian_GivenBigEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0x40, 0x7A, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const double expected = 420.0;
+        double actual = stream.ReadDouble(Endianness.BigEndian);
+
+        Assert.AreEqual(8, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [TestMethod]
+    public void ReadDouble_ShouldWriteLittleEndian_GivenLittleEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x7A, 0x40};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const double expected = 420.0;
+        double actual = stream.ReadDouble(Endianness.LittleEndian);
+
+        Assert.AreEqual(8, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+}

X10D.Tests/src/IO/StreamTests.ReadInt16.cs

@@ -0,0 +1,67 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.IO;
+
+namespace X10D.Tests.IO;
+
+public partial class StreamTests
+{
+    [TestMethod]
+    public void ReadInt16_ShouldThrowArgumentException_GivenNonReadableStream()
+    {
+        Stream stream = new DummyStream();
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt16());
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt16(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt16(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadInt16_ShouldThrowArgumentNullException_GivenNullStream()
+    {
+        Stream stream = null!;
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt16());
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt16(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt16(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadInt16_ShouldThrowArgumentOutOfRangeException_GivenInvalidEndiannessValue()
+    {
+        // we don't need to enclose this stream in a using declaration, since disposing a
+        // null stream is meaningless. NullStream.Dispose actually does nothing, anyway.
+        // that - coupled with the fact that encapsulating the stream in a using declaration causes the
+        // analyser to trip up and think the stream is disposed by the time the local is captured in
+        // assertion lambda - means this line is fine as it is. please do not change.
+        Stream stream = Stream.Null;
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => stream.ReadInt16((Endianness)(-1)));
+    }
+
+    [TestMethod]
+    public void ReadInt16_ShouldReadBigEndian_GivenBigEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0x01, 0xA4};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const short expected = 420;
+        short actual = stream.ReadInt16(Endianness.BigEndian);
+
+        Assert.AreEqual(2, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [TestMethod]
+    public void ReadInt16_ShouldReadLittleEndian_GivenLittleEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0xA4, 0x01};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const short expected = 420;
+        short actual = stream.ReadInt16(Endianness.LittleEndian);
+
+        Assert.AreEqual(2, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+}

X10D.Tests/src/IO/StreamTests.ReadInt32.cs

@@ -0,0 +1,67 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.IO;
+
+namespace X10D.Tests.IO;
+
+public partial class StreamTests
+{
+    [TestMethod]
+    public void ReadInt32_ShouldThrowArgumentException_GivenNonReadableStream()
+    {
+        Stream stream = new DummyStream();
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt32());
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt32(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt32(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadInt32_ShouldThrowArgumentNullException_GivenNullStream()
+    {
+        Stream stream = null!;
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt32());
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt32(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt32(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadInt32_ShouldThrowArgumentOutOfRangeException_GivenInvalidEndiannessValue()
+    {
+        // we don't need to enclose this stream in a using declaration, since disposing a
+        // null stream is meaningless. NullStream.Dispose actually does nothing, anyway.
+        // that - coupled with the fact that encapsulating the stream in a using declaration causes the
+        // analyser to trip up and think the stream is disposed by the time the local is captured in
+        // assertion lambda - means this line is fine as it is. please do not change.
+        Stream stream = Stream.Null;
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => stream.ReadInt32((Endianness)(-1)));
+    }
+
+    [TestMethod]
+    public void ReadInt32_ShouldReadBigEndian_GivenBigEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0x00, 0x00, 0x01, 0xA4};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const int expected = 420;
+        int actual = stream.ReadInt32(Endianness.BigEndian);
+
+        Assert.AreEqual(4, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [TestMethod]
+    public void ReadInt32_ShouldReadLittleEndian_GivenLittleEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0xA4, 0x01, 0x00, 0x00};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const int expected = 420;
+        int actual = stream.ReadInt32(Endianness.LittleEndian);
+
+        Assert.AreEqual(4, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+}

X10D.Tests/src/IO/StreamTests.ReadInt64.cs

@@ -0,0 +1,67 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.IO;
+
+namespace X10D.Tests.IO;
+
+public partial class StreamTests
+{
+    [TestMethod]
+    public void ReadInt64_ShouldThrowArgumentException_GivenNonReadableStream()
+    {
+        Stream stream = new DummyStream();
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt64());
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt64(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentException>(() => stream.ReadInt64(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadInt64_ShouldThrowArgumentNullException_GivenNullStream()
+    {
+        Stream stream = null!;
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt64());
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt64(Endianness.LittleEndian));
+        Assert.ThrowsException<ArgumentNullException>(() => stream.ReadInt64(Endianness.BigEndian));
+    }
+
+    [TestMethod]
+    public void ReadInt64_ShouldThrowArgumentOutOfRangeException_GivenInvalidEndiannessValue()
+    {
+        // we don't need to enclose this stream in a using declaration, since disposing a
+        // null stream is meaningless. NullStream.Dispose actually does nothing, anyway.
+        // that - coupled with the fact that encapsulating the stream in a using declaration causes the
+        // analyser to trip up and think the stream is disposed by the time the local is captured in
+        // assertion lambda - means this line is fine as it is. please do not change.
+        Stream stream = Stream.Null;
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => stream.ReadInt64((Endianness)(-1)));
+    }
+
+    [TestMethod]
+    public void ReadInt64_ShouldReadBigEndian_GivenBigEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xA4};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const long expected = 420;
+        long actual = stream.ReadInt64(Endianness.BigEndian);
+
+        Assert.AreEqual(8, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [TestMethod]
+    public void ReadInt64_ShouldWriteLittleEndian_GivenLittleEndian()
+    {
+        using var stream = new MemoryStream();
+        ReadOnlySpan<byte> bytes = stackalloc byte[] {0xA4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+        stream.Write(bytes);
+        stream.Position = 0;
+
+        const long expected = 420;
+        long actual = stream.ReadInt64(Endianness.LittleEndian);
+
+        Assert.AreEqual(8, stream.Position);
+        Assert.AreEqual(expected, actual);
+    }
+}