revamped and added SC stream tests

tests/SharpCompress.Test/Streams/SharpCompressStreamEdgeTest.cs

@@ -0,0 +1,99 @@
+using System;
+using System.IO;
+using SharpCompress.IO;
+using SharpCompress.Test.Mocks;
+using Xunit;
+
+namespace SharpCompress.Test.Streams;
+
+public class SharpCompressStreamEdgeTest
+{
+    [Fact]
+    public void Dispose_WithLeaveStreamOpenTrue_DoesNotDisposeUnderlying()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var stream = SharpCompressStream.CreateNonDisposing(ms);
+        stream.Dispose();
+        Assert.Equal(0, ms.Position);
+        Assert.True(ms.CanRead);
+    }
+
+    [Fact]
+    public void Dispose_WithLeaveStreamOpenFalse_DisposesUnderlying()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var nonSeekableMs = new ForwardOnlyStream(ms);
+        var stream = SharpCompressStream.Create(nonSeekableMs, 128);
+        stream.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => ms.Read(new byte[1], 0, 1));
+    }
+
+    [Fact]
+    public void Dispose_WithThrowOnDisposeTrue_ThrowsInvalidOperation()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var stream = SharpCompressStream.CreateNonDisposing(ms);
+        stream.ThrowOnDispose = true;
+        Assert.Throws<InvalidOperationException>(() => stream.Dispose());
+    }
+
+    [Fact]
+    public void Read_ZeroCount_ReturnsZero()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var stream = SharpCompressStream.CreateNonDisposing(ms);
+        var buffer = new byte[10];
+        int bytesRead = stream.Read(buffer, 0, 0);
+        Assert.Equal(0, bytesRead);
+    }
+
+    [Fact]
+    public void Read_AtEndOfStream_ReturnsZero()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var stream = SharpCompressStream.CreateNonDisposing(ms);
+        var buffer = new byte[10];
+        int bytesRead = stream.Read(buffer, 0, buffer.Length);
+        Assert.Equal(5, bytesRead);
+        bytesRead = stream.Read(buffer, 0, buffer.Length);
+        Assert.Equal(0, bytesRead);
+    }
+
+    [Fact]
+    public void Position_InitialValue_IsZero()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var nonSeekableMs = new ForwardOnlyStream(ms);
+        var stream = SharpCompressStream.Create(nonSeekableMs, 128);
+        Assert.Equal(0, stream.Position);
+    }
+
+    [Fact]
+    public void CanRead_AlwaysReturnsTrue()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var stream = SharpCompressStream.CreateNonDisposing(ms);
+        Assert.True(stream.CanRead);
+    }
+
+    [Fact]
+    public void CanSeek_PassthroughMode_DelegatesToUnderlying()
+    {
+        var seekableMs = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var nonSeekableMs = new ForwardOnlyStream(new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }));
+
+        var seekableStream = SharpCompressStream.CreateNonDisposing(seekableMs);
+        var nonSeekableStream = SharpCompressStream.CreateNonDisposing(nonSeekableMs);
+
+        Assert.True(seekableStream.CanSeek);
+        Assert.False(nonSeekableStream.CanSeek);
+    }
+
+    [Fact]
+    public void BaseStream_ReturnsUnderlyingStream()
+    {
+        var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        var stream = SharpCompressStream.CreateNonDisposing(ms);
+        Assert.Same(ms, stream.BaseStream());
+    }
+}