diff --git a/src/SharpCompress/Common/GZip/GZipFilePart.cs b/src/SharpCompress/Common/GZip/GZipFilePart.cs index 30cc20e9..2aecd3ff 100644 --- a/src/SharpCompress/Common/GZip/GZipFilePart.cs +++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs @@ -30,7 +30,7 @@ namespace SharpCompress.Common.GZip internal override Stream GetCompressedStream() { - return new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default, false); + return new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default); } internal override Stream GetRawStream() diff --git a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs index d05840ee..f3b67960 100644 --- a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs +++ b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs @@ -90,14 +90,11 @@ namespace SharpCompress.Common.Rar.Headers } catch (Exception e) { - if (!Options.LeaveStreamOpen) - { #if NET35 - reader.Close(); + reader.Close(); #else - reader.Dispose(); + reader.Dispose(); #endif - } throw new InvalidFormatException("Error trying to read rar signature.", e); } return stream; diff --git a/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs b/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs index ea42d174..97c5e8ad 100644 --- a/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs +++ b/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs @@ -24,7 +24,6 @@ namespace SharpCompress.Common.SevenZip } } - internal Stream BaseStream { get; private set; } internal CFileItem Header { get; } internal CFolder Folder { get; } internal int Index { get; } diff --git a/src/SharpCompress/Common/Volume.cs b/src/SharpCompress/Common/Volume.cs index 87b0d856..93cbfefa 100644 --- a/src/SharpCompress/Common/Volume.cs +++ b/src/SharpCompress/Common/Volume.cs @@ -33,7 +33,7 @@ namespace SharpCompress.Common public void Dispose() { - if (!ReaderOptions.LeaveStreamOpen && !disposed) + if (!disposed) { actualStream.Dispose(); disposed = true; diff --git a/src/SharpCompress/Common/Zip/ZipFilePart.cs b/src/SharpCompress/Common/Zip/ZipFilePart.cs index 9b2e74ca..f68a1f6f 100644 --- a/src/SharpCompress/Common/Zip/ZipFilePart.cs +++ b/src/SharpCompress/Common/Zip/ZipFilePart.cs @@ -73,7 +73,7 @@ namespace SharpCompress.Common.Zip } case ZipCompressionMethod.BZip2: { - return new BZip2Stream(stream, CompressionMode.Decompress); + return new BZip2Stream(stream, CompressionMode.Decompress, false); } case ZipCompressionMethod.LZMA: { diff --git a/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs b/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs index 590313d3..4566bf03 100644 --- a/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs +++ b/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs @@ -12,19 +12,18 @@ namespace SharpCompress.Compressors.BZip2 /// /// The stream to read from /// Compression Mode - /// Leave the underlying stream open when disposed. - /// Should the BZip2 stream continue to decompress the stream when the End Marker is found. - public BZip2Stream(Stream stream, CompressionMode compressionMode, bool leaveOpen = false, - bool decompressContacted = false) + /// Decompress Concatenated + public BZip2Stream(Stream stream, CompressionMode compressionMode, + bool decompressConcatenated) { Mode = compressionMode; if (Mode == CompressionMode.Compress) { - this.stream = new CBZip2OutputStream(stream, leaveOpen); + this.stream = new CBZip2OutputStream(stream); } else { - this.stream = new CBZip2InputStream(stream, decompressContacted, leaveOpen); + this.stream = new CBZip2InputStream(stream, decompressConcatenated); } } diff --git a/src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs b/src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs index 0656801e..4168db4b 100644 --- a/src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs +++ b/src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs @@ -119,7 +119,6 @@ namespace SharpCompress.Compressors.BZip2 private readonly int[] minLens = new int[BZip2Constants.N_GROUPS]; private Stream bsStream; - private bool leaveOpen; private bool streamEnd; @@ -147,12 +146,12 @@ namespace SharpCompress.Compressors.BZip2 private char z; private bool isDisposed; - public CBZip2InputStream(Stream zStream, bool decompressConcatenated, bool leaveOpen) + public CBZip2InputStream(Stream zStream, bool decompressConcatenated) { this.decompressConcatenated = decompressConcatenated; ll8 = null; tt = null; - BsSetStream(zStream, leaveOpen); + BsSetStream(zStream); Initialize(true); InitBlock(); SetupBlock(); @@ -354,29 +353,15 @@ namespace SharpCompress.Compressors.BZip2 private void BsFinishedWithStream() { - try - { - if (bsStream != null) - { - if (!leaveOpen) - { - bsStream.Dispose(); - } - bsStream = null; - } - } - catch - { - //ignore - } + bsStream?.Dispose(); + bsStream = null; } - private void BsSetStream(Stream f, bool leaveOpen) + private void BsSetStream(Stream f) { bsStream = f; bsLive = 0; bsBuff = 0; - this.leaveOpen = leaveOpen; } private int BsR(int n) diff --git a/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs b/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs index 9f4817cc..38922294 100644 --- a/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs +++ b/src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs @@ -303,16 +303,11 @@ namespace SharpCompress.Compressors.BZip2 private int runLength; public CBZip2OutputStream(Stream inStream) - : this(inStream, 9, false) + : this(inStream, 9) { } - public CBZip2OutputStream(Stream inStream, bool leaveOpen) - : this(inStream, 9, leaveOpen) - { - } - - public CBZip2OutputStream(Stream inStream, int inBlockSize, bool leaveOpen) + public CBZip2OutputStream(Stream inStream, int inBlockSize) { block = null; quadrant = null; @@ -322,7 +317,7 @@ namespace SharpCompress.Compressors.BZip2 inStream.WriteByte((byte)'B'); inStream.WriteByte((byte)'Z'); - BsSetStream(inStream, leaveOpen); + BsSetStream(inStream); workFactor = 50; if (inBlockSize > 9) @@ -441,10 +436,7 @@ namespace SharpCompress.Compressors.BZip2 disposed = true; base.Dispose(); - if (!leaveOpen) - { - bsStream.Dispose(); - } + bsStream?.Dispose(); bsStream = null; } } @@ -596,13 +588,12 @@ namespace SharpCompress.Compressors.BZip2 } } - private void BsSetStream(Stream f, bool leaveOpen) + private void BsSetStream(Stream f) { bsStream = f; bsLive = 0; bsBuff = 0; bytesOut = 0; - this.leaveOpen = leaveOpen; } private void BsFinishedWithStream() @@ -1057,7 +1048,6 @@ namespace SharpCompress.Compressors.BZip2 } private Stream bsStream; - private bool leaveOpen; private void SimpleSort(int lo, int hi, int d) { diff --git a/src/SharpCompress/Compressors/Deflate/DeflateStream.cs b/src/SharpCompress/Compressors/Deflate/DeflateStream.cs index d041533e..a771d66e 100644 --- a/src/SharpCompress/Compressors/Deflate/DeflateStream.cs +++ b/src/SharpCompress/Compressors/Deflate/DeflateStream.cs @@ -37,10 +37,9 @@ namespace SharpCompress.Compressors.Deflate public DeflateStream(Stream stream, CompressionMode mode, CompressionLevel level = CompressionLevel.Default, - bool leaveOpen = false, Encoding forceEncoding = null) { - _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen, forceEncoding); + _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, forceEncoding); } #region Zlib properties @@ -216,7 +215,6 @@ namespace SharpCompress.Compressors.Deflate /// /// /// This may or may not result in a Close() call on the captive stream. - /// See the constructors that have a leaveOpen parameter for more information. /// protected override void Dispose(bool disposing) { @@ -224,9 +222,9 @@ namespace SharpCompress.Compressors.Deflate { if (!_disposed) { - if (disposing && (_baseStream != null)) + if (disposing) { - _baseStream.Dispose(); + _baseStream?.Dispose(); } _disposed = true; } diff --git a/src/SharpCompress/Compressors/Deflate/GZipStream.cs b/src/SharpCompress/Compressors/Deflate/GZipStream.cs index 6784b6d4..decbc8ad 100644 --- a/src/SharpCompress/Compressors/Deflate/GZipStream.cs +++ b/src/SharpCompress/Compressors/Deflate/GZipStream.cs @@ -51,23 +51,18 @@ namespace SharpCompress.Compressors.Deflate private readonly Encoding _encoding; public GZipStream(Stream stream, CompressionMode mode) - : this(stream, mode, CompressionLevel.Default, false, Encoding.UTF8) + : this(stream, mode, CompressionLevel.Default, Encoding.UTF8) { } public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level) - : this(stream, mode, level, false, Encoding.UTF8) + : this(stream, mode, level, Encoding.UTF8) { } - public GZipStream(Stream stream, CompressionMode mode, bool leaveOpen) - : this(stream, mode, CompressionLevel.Default, leaveOpen, Encoding.UTF8) + public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, Encoding encoding) { - } - - public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen, Encoding encoding) - { - BaseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen, encoding); + BaseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, encoding); _encoding = encoding; } @@ -200,7 +195,6 @@ namespace SharpCompress.Compressors.Deflate /// /// /// This may or may not result in a Close() call on the captive stream. - /// See the doc on constructors that take a leaveOpen parameter for more information. /// protected override void Dispose(bool disposing) { diff --git a/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs b/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs index 875717ec..a7159122 100644 --- a/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs +++ b/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs @@ -50,7 +50,6 @@ namespace SharpCompress.Compressors.Deflate protected internal ZlibStreamFlavor _flavor; protected internal CompressionMode _compressionMode; protected internal CompressionLevel _level; - protected internal bool _leaveOpen; protected internal byte[] _workingBuffer; protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault; protected internal byte[] _buf1 = new byte[1]; @@ -83,14 +82,12 @@ namespace SharpCompress.Compressors.Deflate CompressionMode compressionMode, CompressionLevel level, ZlibStreamFlavor flavor, - bool leaveOpen, Encoding encoding) { _flushMode = FlushType.None; //this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT]; _stream = stream; - _leaveOpen = leaveOpen; _compressionMode = compressionMode; _flavor = flavor; _level = level; @@ -361,10 +358,7 @@ namespace SharpCompress.Compressors.Deflate finally { end(); - if (!_leaveOpen) - { - _stream.Dispose(); - } + _stream?.Dispose(); _stream = null; } } diff --git a/src/SharpCompress/Compressors/Deflate/ZlibStream.cs b/src/SharpCompress/Compressors/Deflate/ZlibStream.cs index b94ceea8..6a644f39 100644 --- a/src/SharpCompress/Compressors/Deflate/ZlibStream.cs +++ b/src/SharpCompress/Compressors/Deflate/ZlibStream.cs @@ -37,23 +37,18 @@ namespace SharpCompress.Compressors.Deflate private bool _disposed; public ZlibStream(Stream stream, CompressionMode mode) - : this(stream, mode, CompressionLevel.Default, false, Encoding.UTF8) + : this(stream, mode, CompressionLevel.Default, Encoding.UTF8) { } public ZlibStream(Stream stream, CompressionMode mode, CompressionLevel level) - : this(stream, mode, level, false, Encoding.UTF8) + : this(stream, mode, level, Encoding.UTF8) { } - public ZlibStream(Stream stream, CompressionMode mode, bool leaveOpen) - : this(stream, mode, CompressionLevel.Default, leaveOpen, Encoding.UTF8) + public ZlibStream(Stream stream, CompressionMode mode, CompressionLevel level, Encoding encoding) { - } - - public ZlibStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen, Encoding encoding) - { - _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen, encoding); + _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, encoding); } #region Zlib properties @@ -208,7 +203,6 @@ namespace SharpCompress.Compressors.Deflate /// /// /// This may or may not result in a Close() call on the captive stream. - /// See the constructors that have a leaveOpen parameter for more information. /// protected override void Dispose(bool disposing) { @@ -216,9 +210,9 @@ namespace SharpCompress.Compressors.Deflate { if (!_disposed) { - if (disposing && (_baseStream != null)) + if (disposing) { - _baseStream.Dispose(); + _baseStream?.Dispose(); } _disposed = true; } diff --git a/src/SharpCompress/Compressors/Deflate64/Deflate64Stream.cs b/src/SharpCompress/Compressors/Deflate64/Deflate64Stream.cs index 1c8a5d9f..341dc6ff 100644 --- a/src/SharpCompress/Compressors/Deflate64/Deflate64Stream.cs +++ b/src/SharpCompress/Compressors/Deflate64/Deflate64Stream.cs @@ -11,19 +11,16 @@ using System.Runtime.CompilerServices; namespace SharpCompress.Compressors.Deflate64 { - public sealed partial class Deflate64Stream : Stream + public sealed class Deflate64Stream : Stream { - internal const int DefaultBufferSize = 8192; + private const int DefaultBufferSize = 8192; private Stream _stream; private CompressionMode _mode; - private bool _leaveOpen; private InflaterManaged _inflater; private byte[] _buffer; - public Deflate64Stream(Stream stream, CompressionMode mode, - CompressionLevel level = CompressionLevel.Default, - bool leaveOpen = false) + public Deflate64Stream(Stream stream, CompressionMode mode) { if (stream == null) throw new ArgumentNullException(nameof(stream)); @@ -32,13 +29,13 @@ namespace SharpCompress.Compressors.Deflate64 if (!stream.CanRead) throw new ArgumentException("Deflate64: input stream is not readable", nameof(stream)); - InitializeInflater(stream, leaveOpen, ZipCompressionMethod.Deflate64); + InitializeInflater(stream, ZipCompressionMethod.Deflate64); } /// /// Sets up this DeflateManagedStream to be used for Inflation/Decompression /// - internal void InitializeInflater(Stream stream, bool leaveOpen, ZipCompressionMethod method = ZipCompressionMethod.Deflate) + internal void InitializeInflater(Stream stream, ZipCompressionMethod method = ZipCompressionMethod.Deflate) { Debug.Assert(stream != null); Debug.Assert(method == ZipCompressionMethod.Deflate || method == ZipCompressionMethod.Deflate64); @@ -49,7 +46,6 @@ namespace SharpCompress.Compressors.Deflate64 _stream = stream; _mode = CompressionMode.Decompress; - _leaveOpen = leaveOpen; _buffer = new byte[DefaultBufferSize]; } @@ -234,8 +230,10 @@ namespace SharpCompress.Compressors.Deflate64 // In this case, we still need to clean up internal resources, hence the inner finally blocks. try { - if (disposing && !_leaveOpen && _stream != null) - _stream.Dispose(); + if (disposing) + { + _stream?.Dispose(); + } } finally { diff --git a/src/SharpCompress/Compressors/LZMA/LZipStream.cs b/src/SharpCompress/Compressors/LZMA/LZipStream.cs index fbb78f5e..d3f95e11 100644 --- a/src/SharpCompress/Compressors/LZMA/LZipStream.cs +++ b/src/SharpCompress/Compressors/LZMA/LZipStream.cs @@ -19,15 +19,13 @@ namespace SharpCompress.Compressors.LZMA private readonly Stream stream; private readonly CountingWritableSubStream rawStream; private bool disposed; - private readonly bool leaveOpen; private bool finished; private long writeCount; - public LZipStream(Stream stream, CompressionMode mode, bool leaveOpen = false) + public LZipStream(Stream stream, CompressionMode mode) { Mode = mode; - this.leaveOpen = leaveOpen; if (mode == CompressionMode.Decompress) { @@ -87,10 +85,7 @@ namespace SharpCompress.Compressors.LZMA if (disposing) { Finish(); - if (!leaveOpen) - { - rawStream.Dispose(); - } + rawStream?.Dispose(); } } diff --git a/src/SharpCompress/IO/NonDisposingStream.cs b/src/SharpCompress/IO/NonDisposingStream.cs index 0c5363d1..b5c7b834 100644 --- a/src/SharpCompress/IO/NonDisposingStream.cs +++ b/src/SharpCompress/IO/NonDisposingStream.cs @@ -1,17 +1,24 @@ -using System.IO; +using System; +using System.IO; namespace SharpCompress.IO { internal class NonDisposingStream : Stream { - public NonDisposingStream(Stream stream) + public NonDisposingStream(Stream stream, bool throwOnDispose = false) { Stream = stream; + ThrowOnDispose = false; } + public bool ThrowOnDispose { get; set; } + protected override void Dispose(bool disposing) { - //don't dispose anything + if (ThrowOnDispose) + { + throw new InvalidOperationException(); + } } public Stream Stream { get; } diff --git a/src/SharpCompress/Readers/ReaderFactory.cs b/src/SharpCompress/Readers/ReaderFactory.cs index cf22fcc0..ec7d15c9 100644 --- a/src/SharpCompress/Readers/ReaderFactory.cs +++ b/src/SharpCompress/Readers/ReaderFactory.cs @@ -58,7 +58,7 @@ namespace SharpCompress.Readers if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); - BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, true); + BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); @@ -70,7 +70,7 @@ namespace SharpCompress.Readers if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); - LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true); + LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); diff --git a/src/SharpCompress/Readers/Tar/TarReader.cs b/src/SharpCompress/Readers/Tar/TarReader.cs index 809ea3b5..f83e444e 100644 --- a/src/SharpCompress/Readers/Tar/TarReader.cs +++ b/src/SharpCompress/Readers/Tar/TarReader.cs @@ -102,7 +102,7 @@ namespace SharpCompress.Readers.Tar if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); - LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, false); + LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); diff --git a/src/SharpCompress/Writers/GZip/GZipWriter.cs b/src/SharpCompress/Writers/GZip/GZipWriter.cs index 978fcf60..735d89f5 100644 --- a/src/SharpCompress/Writers/GZip/GZipWriter.cs +++ b/src/SharpCompress/Writers/GZip/GZipWriter.cs @@ -3,6 +3,7 @@ using System.IO; using SharpCompress.Common; using SharpCompress.Compressors; using SharpCompress.Compressors.Deflate; +using SharpCompress.IO; namespace SharpCompress.Writers.GZip { @@ -13,9 +14,12 @@ namespace SharpCompress.Writers.GZip public GZipWriter(Stream destination, GZipWriterOptions options = null) : base(ArchiveType.GZip, options ?? new GZipWriterOptions()) { + if (WriterOptions.LeaveStreamOpen) + { + destination = new NonDisposingStream(destination); + } InitalizeStream(new GZipStream(destination, CompressionMode.Compress, - options?.CompressionLevel ?? CompressionLevel.Default, - WriterOptions.LeaveStreamOpen, + options?.CompressionLevel ?? CompressionLevel.Default, WriterOptions.ArchiveEncoding.GetEncoding())); } diff --git a/src/SharpCompress/Writers/Tar/TarWriter.cs b/src/SharpCompress/Writers/Tar/TarWriter.cs index 659c60e1..f6f06c56 100644 --- a/src/SharpCompress/Writers/Tar/TarWriter.cs +++ b/src/SharpCompress/Writers/Tar/TarWriter.cs @@ -6,6 +6,7 @@ using SharpCompress.Compressors; using SharpCompress.Compressors.BZip2; using SharpCompress.Compressors.Deflate; using SharpCompress.Compressors.LZMA; +using SharpCompress.IO; namespace SharpCompress.Writers.Tar { @@ -22,23 +23,27 @@ namespace SharpCompress.Writers.Tar { throw new ArgumentException("Tars require writable streams."); } + if (WriterOptions.LeaveStreamOpen) + { + destination = new NonDisposingStream(destination); + } switch (options.CompressionType) { case CompressionType.None: break; case CompressionType.BZip2: { - destination = new BZip2Stream(destination, CompressionMode.Compress, true); + destination = new BZip2Stream(destination, CompressionMode.Compress, false); } break; case CompressionType.GZip: { - destination = new GZipStream(destination, CompressionMode.Compress, true); + destination = new GZipStream(destination, CompressionMode.Compress); } break; case CompressionType.LZip: { - destination = new LZipStream(destination, CompressionMode.Compress, true); + destination = new LZipStream(destination, CompressionMode.Compress); } break; default: diff --git a/src/SharpCompress/Writers/Zip/ZipWriter.cs b/src/SharpCompress/Writers/Zip/ZipWriter.cs index 3a29ac63..85e0c8dd 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriter.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs @@ -37,6 +37,11 @@ namespace SharpCompress.Writers.Zip compressionType = zipWriterOptions.CompressionType; compressionLevel = zipWriterOptions.DeflateCompressionLevel; + + if (WriterOptions.LeaveStreamOpen) + { + destination = new NonDisposingStream(destination); + } InitalizeStream(destination); } @@ -312,12 +317,11 @@ namespace SharpCompress.Writers.Zip } case ZipCompressionMethod.Deflate: { - return new DeflateStream(counting, CompressionMode.Compress, compressionLevel, - true); + return new DeflateStream(counting, CompressionMode.Compress, compressionLevel); } case ZipCompressionMethod.BZip2: { - return new BZip2Stream(counting, CompressionMode.Compress, true); + return new BZip2Stream(counting, CompressionMode.Compress, false); } case ZipCompressionMethod.LZMA: { diff --git a/tests/SharpCompress.Test/ArchiveTests.cs b/tests/SharpCompress.Test/ArchiveTests.cs index 757b10a1..98546313 100644 --- a/tests/SharpCompress.Test/ArchiveTests.cs +++ b/tests/SharpCompress.Test/ArchiveTests.cs @@ -4,6 +4,7 @@ using System.IO; using System.Linq; using SharpCompress.Archives; using SharpCompress.Common; +using SharpCompress.IO; using SharpCompress.Readers; using Xunit; @@ -23,7 +24,7 @@ namespace SharpCompress.Test foreach (var path in testArchives) { ResetScratch(); - using (Stream stream = File.OpenRead(path)) + using (var stream = new NonDisposingStream(File.OpenRead(path), true)) using (var archive = ArchiveFactory.Open(stream)) { Assert.True(archive.IsSolid); @@ -46,6 +47,7 @@ namespace SharpCompress.Test Overwrite = true }); } + stream.ThrowOnDispose = false; } VerifyFiles(); } @@ -67,7 +69,7 @@ namespace SharpCompress.Test foreach (var path in testArchives) { ResetScratch(); - using (Stream stream = File.OpenRead(path)) + using (var stream = new NonDisposingStream(File.OpenRead(path))) using (var archive = ArchiveFactory.Open(stream, readerOptions)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) @@ -78,6 +80,7 @@ namespace SharpCompress.Test Overwrite = true }); } + stream.ThrowOnDispose = false; } VerifyFiles(); }