diff --git a/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs b/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs index 91179ccf..4c0127c5 100644 --- a/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs +++ b/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs @@ -1,5 +1,8 @@ using System; +using System.Buffers; using System.IO; +using System.Threading; +using System.Threading.Tasks; namespace SharpCompress.Compressors.BZip2 { @@ -65,12 +68,17 @@ namespace SharpCompress.Compressors.BZip2 public override int Read(byte[] buffer, int offset, int count) { - return stream.Read(buffer, offset, count); + throw new NotImplementedException(); + } + + public override ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken = default) + { + return stream.ReadAsync(buffer, cancellationToken); } public override int ReadByte() { - return stream.ReadByte(); + throw new NotImplementedException(); } public override long Seek(long offset, SeekOrigin origin) @@ -83,28 +91,19 @@ namespace SharpCompress.Compressors.BZip2 stream.SetLength(value); } -#if !NET461 && !NETSTANDARD2_0 - - public override int Read(Span buffer) + public override ValueTask WriteAsync(ReadOnlyMemory buffer, CancellationToken cancellationToken = new CancellationToken()) { - return stream.Read(buffer); + return stream.WriteAsync(buffer, cancellationToken); } - public override void Write(ReadOnlySpan buffer) - { - stream.Write(buffer); - } - -#endif - public override void Write(byte[] buffer, int offset, int count) { - stream.Write(buffer, offset, count); + throw new NotImplementedException(); } public override void WriteByte(byte value) { - stream.WriteByte(value); + throw new NotImplementedException(); } /// @@ -112,11 +111,12 @@ namespace SharpCompress.Compressors.BZip2 /// /// /// - public static bool IsBZip2(Stream stream) + public static async ValueTask IsBZip2Async(Stream stream, CancellationToken cancellationToken) { - BinaryReader br = new BinaryReader(stream); - byte[] chars = br.ReadBytes(2); - if (chars.Length < 2 || chars[0] != 'B' || chars[1] != 'Z') + using var rented = MemoryPool.Shared.Rent(2); + var chars = rented.Memory.Slice(0, 2); + await stream.ReadAsync(chars, cancellationToken); + if (chars.Length < 2 || chars.Span[0] != 'B' || chars.Span[1] != 'Z') { return false; } diff --git a/src/SharpCompress/Compressors/Xz/BinaryUtils.cs b/src/SharpCompress/Compressors/Xz/BinaryUtils.cs index 73ae5203..a56c2ae1 100644 --- a/src/SharpCompress/Compressors/Xz/BinaryUtils.cs +++ b/src/SharpCompress/Compressors/Xz/BinaryUtils.cs @@ -1,5 +1,8 @@ using System; +using System.Buffers; using System.IO; +using System.Threading; +using System.Threading.Tasks; namespace SharpCompress.Compressors.Xz { @@ -15,20 +18,20 @@ namespace SharpCompress.Compressors.Xz { return unchecked((uint)ReadLittleEndianInt32(reader)); } - public static int ReadLittleEndianInt32(this Stream stream) + public static async ValueTask ReadLittleEndianInt32(this Stream stream, CancellationToken cancellationToken) { - byte[] bytes = new byte[4]; - var read = stream.ReadFully(bytes); - if (!read) + using var buffer = MemoryPool.Shared.Rent(4); + var read = await stream.ReadAsync(buffer.Memory.Slice(0, 4), cancellationToken); + if (read != 4) { throw new EndOfStreamException(); } - return (bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24)); + return (buffer.Memory.Span[0] + (buffer.Memory.Span[1] << 8) + (buffer.Memory.Span[2] << 16) + (buffer.Memory.Span[3] << 24)); } - internal static uint ReadLittleEndianUInt32(this Stream stream) + internal static async ValueTask ReadLittleEndianUInt32(this Stream stream, CancellationToken cancellationToken) { - return unchecked((uint)ReadLittleEndianInt32(stream)); + return unchecked((uint)await ReadLittleEndianInt32(stream, cancellationToken)); } internal static byte[] ToBigEndianBytes(this uint uint32) diff --git a/src/SharpCompress/Compressors/Xz/Crc32.cs b/src/SharpCompress/Compressors/Xz/Crc32.cs index 710cd497..79ee5e45 100644 --- a/src/SharpCompress/Compressors/Xz/Crc32.cs +++ b/src/SharpCompress/Compressors/Xz/Crc32.cs @@ -12,17 +12,17 @@ namespace SharpCompress.Compressors.Xz private static UInt32[] defaultTable; - public static UInt32 Compute(byte[] buffer) + public static UInt32 Compute(ReadOnlyMemory buffer) { return Compute(DefaultSeed, buffer); } - public static UInt32 Compute(UInt32 seed, byte[] buffer) + public static UInt32 Compute(UInt32 seed, ReadOnlyMemory buffer) { return Compute(DefaultPolynomial, seed, buffer); } - public static UInt32 Compute(UInt32 polynomial, UInt32 seed, byte[] buffer) + public static UInt32 Compute(UInt32 polynomial, UInt32 seed, ReadOnlyMemory buffer) { return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length); } @@ -61,12 +61,12 @@ namespace SharpCompress.Compressors.Xz return createTable; } - private static UInt32 CalculateHash(UInt32[] table, UInt32 seed, IList buffer, int start, int size) + private static UInt32 CalculateHash(UInt32[] table, UInt32 seed, ReadOnlyMemory buffer, int start, int size) { var crc = seed; for (var i = start; i < size - start; i++) { - crc = (crc >> 8) ^ table[buffer[i] ^ crc & 0xff]; + crc = (crc >> 8) ^ table[buffer.Span[i] ^ crc & 0xff]; } return crc; diff --git a/src/SharpCompress/Compressors/Xz/ReadOnlyStream.cs b/src/SharpCompress/Compressors/Xz/ReadOnlyStream.cs index 0c1b53b4..a8324366 100644 --- a/src/SharpCompress/Compressors/Xz/ReadOnlyStream.cs +++ b/src/SharpCompress/Compressors/Xz/ReadOnlyStream.cs @@ -23,6 +23,11 @@ namespace SharpCompress.Compressors.Xz set => throw new NotSupportedException(); } + public override int Read(byte[] buffer, int offset, int count) + { + throw new NotImplementedException(); + } + public override void Flush() { throw new NotSupportedException(); diff --git a/src/SharpCompress/Compressors/Xz/XZBlock.cs b/src/SharpCompress/Compressors/Xz/XZBlock.cs index 6827093b..14b369fe 100644 --- a/src/SharpCompress/Compressors/Xz/XZBlock.cs +++ b/src/SharpCompress/Compressors/Xz/XZBlock.cs @@ -1,8 +1,10 @@ -#nullable disable - +using System; +using System.Buffers; using System.Collections.Generic; using System.IO; using System.Linq; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Compressors.Xz.Filters; namespace SharpCompress.Compressors.Xz @@ -19,7 +21,7 @@ namespace SharpCompress.Compressors.Xz private bool _streamConnected; private int _numFilters; private byte _blockHeaderSizeByte; - private Stream _decomStream; + private Stream? _decomStream; private bool _endOfStream; private bool _paddingSkipped; private bool _crcChecked; @@ -32,12 +34,12 @@ namespace SharpCompress.Compressors.Xz _checkSize = checkSize; } - public override int Read(byte[] buffer, int offset, int count) + public override async ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken = default) { int bytesRead = 0; if (!HeaderIsLoaded) { - LoadHeader(); + await LoadHeader(cancellationToken); } if (!_streamConnected) @@ -45,12 +47,12 @@ namespace SharpCompress.Compressors.Xz ConnectStream(); } - if (!_endOfStream) + if (!_endOfStream && _decomStream is not null) { - bytesRead = _decomStream.Read(buffer, offset, count); + bytesRead = await _decomStream.ReadAsync(buffer, cancellationToken); } - if (bytesRead != count) + if (bytesRead != buffer.Length) { _endOfStream = true; } @@ -105,12 +107,15 @@ namespace SharpCompress.Compressors.Xz _streamConnected = true; } - private void LoadHeader() + private async ValueTask LoadHeader(CancellationToken cancellationToken) { - ReadHeaderSize(); - byte[] headerCache = CacheHeader(); + await ReadHeaderSize(cancellationToken); + using var blockHeaderWithoutCrc = MemoryPool.Shared.Rent(BlockHeaderSize - 4); + var headerCache = blockHeaderWithoutCrc.Memory.Slice(0, BlockHeaderSize - 4); + await CacheHeader(headerCache, cancellationToken); - using (var cache = new MemoryStream(headerCache)) + //TODO: memory-size this + await using (var cache = new MemoryStream(headerCache.ToArray())) using (var cachedReader = new BinaryReader(cache)) { cachedReader.BaseStream.Position = 1; // skip the header size byte @@ -120,33 +125,32 @@ namespace SharpCompress.Compressors.Xz HeaderIsLoaded = true; } - private void ReadHeaderSize() + private async ValueTask ReadHeaderSize(CancellationToken cancellationToken) { - _blockHeaderSizeByte = (byte)BaseStream.ReadByte(); + using var buffer = MemoryPool.Shared.Rent(1); + await BaseStream.ReadAsync(buffer.Memory.Slice(0, 1), cancellationToken); + _blockHeaderSizeByte = buffer.Memory.Span[0]; if (_blockHeaderSizeByte == 0) { throw new XZIndexMarkerReachedException(); } } - private byte[] CacheHeader() + private async ValueTask CacheHeader(Memory blockHeaderWithoutCrc, CancellationToken cancellationToken) { - byte[] blockHeaderWithoutCrc = new byte[BlockHeaderSize - 4]; - blockHeaderWithoutCrc[0] = _blockHeaderSizeByte; - var read = BaseStream.Read(blockHeaderWithoutCrc, 1, BlockHeaderSize - 5); + blockHeaderWithoutCrc.Span[0] = _blockHeaderSizeByte; + var read = await BaseStream.ReadAsync(blockHeaderWithoutCrc.Slice( 1, BlockHeaderSize - 5), cancellationToken); if (read != BlockHeaderSize - 5) { throw new EndOfStreamException("Reached end of stream unexectedly"); } - uint crc = BaseStream.ReadLittleEndianUInt32(); + uint crc = await BaseStream.ReadLittleEndianUInt32(cancellationToken); uint calcCrc = Crc32.Compute(blockHeaderWithoutCrc); if (crc != calcCrc) { throw new InvalidDataException("Block header corrupt"); } - - return blockHeaderWithoutCrc; } private void ReadBlockFlags(BinaryReader reader) diff --git a/src/SharpCompress/Compressors/Xz/XZHeader.cs b/src/SharpCompress/Compressors/Xz/XZHeader.cs index 587f20da..cfa2f63d 100644 --- a/src/SharpCompress/Compressors/Xz/XZHeader.cs +++ b/src/SharpCompress/Compressors/Xz/XZHeader.cs @@ -1,58 +1,65 @@ using System; +using System.Buffers; using System.IO; using System.Linq; using System.Text; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.IO; namespace SharpCompress.Compressors.Xz { public class XZHeader { - private readonly BinaryReader _reader; - private readonly byte[] MagicHeader = { 0xFD, 0x37, 0x7A, 0x58, 0x5a, 0x00 }; + private readonly Stream _stream; + private static readonly ReadOnlyMemory MagicHeader = new(new byte[]{ 0xFD, 0x37, 0x7A, 0x58, 0x5a, 0x00 }); public CheckType BlockCheckType { get; private set; } public int BlockCheckSize => ((((int)BlockCheckType) + 2) / 3) * 4; - public XZHeader(BinaryReader reader) + public XZHeader(Stream reader) { - _reader = reader; + _stream = reader; } - public static XZHeader FromStream(Stream stream) + public static async ValueTask FromStream(Stream stream, CancellationToken cancellationToken = default) { - var header = new XZHeader(new BinaryReader(new NonDisposingStream(stream), Encoding.UTF8)); - header.Process(); + var header = new XZHeader(new NonDisposingStream(stream)); + await header.Process(cancellationToken); return header; } - public void Process() + public async ValueTask Process(CancellationToken cancellationToken = default) { - CheckMagicBytes(_reader.ReadBytes(6)); - ProcessStreamFlags(); + using var header = MemoryPool.Shared.Rent(6); + await _stream.ReadAsync(header.Memory.Slice(0, 6), cancellationToken); + CheckMagicBytes(header.Memory.Slice(0, 6)); + await ProcessStreamFlags(cancellationToken); } - private void ProcessStreamFlags() + private async ValueTask ProcessStreamFlags(CancellationToken cancellationToken) { - byte[] streamFlags = _reader.ReadBytes(2); - UInt32 crc = _reader.ReadLittleEndianUInt32(); - UInt32 calcCrc = Crc32.Compute(streamFlags); + using var header = MemoryPool.Shared.Rent(6); + await _stream.ReadAsync(header.Memory.Slice(0, 2), cancellationToken); + + BlockCheckType = (CheckType)(header.Memory.Span[1] & 0x0F); + byte futureUse = (byte)(header.Memory.Span[1] & 0xF0); + if (futureUse != 0 || header.Memory.Span[0] != 0) + { + throw new InvalidDataException("Unknown XZ Stream Version"); + } + + UInt32 crc = await _stream.ReadLittleEndianUInt32(cancellationToken); + UInt32 calcCrc = Crc32.Compute(header.Memory.Slice(0, 2)); if (crc != calcCrc) { throw new InvalidDataException("Stream header corrupt"); } - - BlockCheckType = (CheckType)(streamFlags[1] & 0x0F); - byte futureUse = (byte)(streamFlags[1] & 0xF0); - if (futureUse != 0 || streamFlags[0] != 0) - { - throw new InvalidDataException("Unknown XZ Stream Version"); - } } - private void CheckMagicBytes(byte[] header) + private void CheckMagicBytes(ReadOnlyMemory header) { - if (!header.SequenceEqual(MagicHeader)) + if (!header.Equals(MagicHeader)) { throw new InvalidDataException("Invalid XZ Stream"); } diff --git a/src/SharpCompress/Compressors/Xz/XZStream.cs b/src/SharpCompress/Compressors/Xz/XZStream.cs index 49b5e801..41a76ff8 100644 --- a/src/SharpCompress/Compressors/Xz/XZStream.cs +++ b/src/SharpCompress/Compressors/Xz/XZStream.cs @@ -1,18 +1,18 @@ -#nullable disable - -using System; +using System; using System.IO; +using System.Threading; +using System.Threading.Tasks; namespace SharpCompress.Compressors.Xz { [CLSCompliant(false)] public sealed class XZStream : XZReadOnlyStream { - public static bool IsXZStream(Stream stream) + public static async ValueTask IsXZStreamAsync(Stream stream, CancellationToken cancellationToken = default) { try { - return null != XZHeader.FromStream(stream); + return null != await XZHeader.FromStream(stream, cancellationToken); } catch (Exception) { @@ -22,7 +22,7 @@ namespace SharpCompress.Compressors.Xz private void AssertBlockCheckTypeIsSupported() { - switch (Header.BlockCheckType) + switch (Header?.BlockCheckType) { case CheckType.NONE: break; @@ -36,11 +36,11 @@ namespace SharpCompress.Compressors.Xz throw new NotSupportedException("Check Type unknown to this version of decoder."); } } - public XZHeader Header { get; private set; } - public XZIndex Index { get; private set; } - public XZFooter Footer { get; private set; } + public XZHeader? Header { get; private set; } + public XZIndex? Index { get; private set; } + public XZFooter? Footer { get; private set; } public bool HeaderIsRead { get; private set; } - private XZBlock _currentBlock; + private XZBlock? _currentBlock; private bool _endOfStream; @@ -48,7 +48,7 @@ namespace SharpCompress.Compressors.Xz { } - public override int Read(byte[] buffer, int offset, int count) + public override async ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken = default) { int bytesRead = 0; if (_endOfStream) @@ -58,11 +58,11 @@ namespace SharpCompress.Compressors.Xz if (!HeaderIsRead) { - ReadHeader(); + await ReadHeader(); } - bytesRead = ReadBlocks(buffer, offset, count); - if (bytesRead < count) + bytesRead = await ReadBlocks(buffer, cancellationToken); + if (bytesRead < buffer.Length) { _endOfStream = true; ReadIndex(); @@ -71,9 +71,9 @@ namespace SharpCompress.Compressors.Xz return bytesRead; } - private void ReadHeader() + private async ValueTask ReadHeader() { - Header = XZHeader.FromStream(BaseStream); + Header = await XZHeader.FromStream(BaseStream); AssertBlockCheckTypeIsSupported(); HeaderIsRead = true; } @@ -90,29 +90,29 @@ namespace SharpCompress.Compressors.Xz // TODO verify footer } - private int ReadBlocks(byte[] buffer, int offset, int count) + private async ValueTask ReadBlocks(Memory buffer, CancellationToken cancellationToken) { int bytesRead = 0; if (_currentBlock is null) { - NextBlock(); + _currentBlock = NextBlock(); } for (; ; ) { try { - if (bytesRead >= count) + if (bytesRead >= buffer.Length) { break; } - int remaining = count - bytesRead; - int newOffset = offset + bytesRead; - int justRead = _currentBlock.Read(buffer, newOffset, remaining); + int remaining = buffer.Length - bytesRead; + int newOffset = bytesRead; + int justRead = await _currentBlock.ReadAsync(buffer.Slice(newOffset, remaining), cancellationToken); if (justRead < remaining) { - NextBlock(); + _currentBlock = NextBlock(); } bytesRead += justRead; @@ -125,9 +125,9 @@ namespace SharpCompress.Compressors.Xz return bytesRead; } - private void NextBlock() + private XZBlock NextBlock() { - _currentBlock = new XZBlock(BaseStream, Header.BlockCheckType, Header.BlockCheckSize); + return new XZBlock(BaseStream, Header!.BlockCheckType, Header!.BlockCheckSize); } } } diff --git a/src/SharpCompress/Readers/ReaderFactory.cs b/src/SharpCompress/Readers/ReaderFactory.cs index 8396a5d4..635b6147 100644 --- a/src/SharpCompress/Readers/ReaderFactory.cs +++ b/src/SharpCompress/Readers/ReaderFactory.cs @@ -1,5 +1,6 @@ using System; using System.IO; +using System.Threading; using System.Threading.Tasks; using SharpCompress.Archives.GZip; //using SharpCompress.Archives.Rar; @@ -27,7 +28,7 @@ namespace SharpCompress.Readers /// /// /// - public static async ValueTask OpenAsync(Stream stream, ReaderOptions? options = null) + public static async ValueTask OpenAsync(Stream stream, ReaderOptions? options = null, CancellationToken cancellationToken = default) { stream.CheckNotNull(nameof(stream)); options ??= new ReaderOptions() @@ -42,11 +43,11 @@ namespace SharpCompress.Readers return ZipReader.Open(rewindableStream, options); } rewindableStream.Rewind(false); - if (await GZipArchive.IsGZipFileAsync(rewindableStream)) + if (await GZipArchive.IsGZipFileAsync(rewindableStream, cancellationToken)) { rewindableStream.Rewind(false); - GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); - if (await TarArchive.IsTarFileAsync(testStream)) + GZipStream testStream = new(rewindableStream, CompressionMode.Decompress); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.GZip); @@ -56,11 +57,11 @@ namespace SharpCompress.Readers } rewindableStream.Rewind(false); - if (BZip2Stream.IsBZip2(rewindableStream)) + if (await BZip2Stream.IsBZip2Async(rewindableStream, cancellationToken)) { rewindableStream.Rewind(false); - BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false); - if (await TarArchive.IsTarFileAsync(testStream)) + BZip2Stream testStream = new(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.BZip2); @@ -71,8 +72,8 @@ namespace SharpCompress.Readers if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); - LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress); - if (await TarArchive.IsTarFileAsync(testStream)) + LZipStream testStream = new(new NonDisposingStream(rewindableStream), CompressionMode.Decompress); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.LZip); @@ -86,17 +87,17 @@ namespace SharpCompress.Readers } */ rewindableStream.Rewind(false); - if (await TarArchive.IsTarFileAsync(rewindableStream)) + if (await TarArchive.IsTarFileAsync(rewindableStream, cancellationToken)) { rewindableStream.Rewind(true); - return await TarReader.OpenAsync(rewindableStream, options); + return await TarReader.OpenAsync(rewindableStream, options, cancellationToken); } rewindableStream.Rewind(false); - if (XZStream.IsXZStream(rewindableStream)) + if (await XZStream.IsXZStreamAsync(rewindableStream, cancellationToken)) { rewindableStream.Rewind(true); - XZStream testStream = new XZStream(rewindableStream); - if (await TarArchive.IsTarFileAsync(testStream)) + XZStream testStream = new(rewindableStream); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.Xz); diff --git a/src/SharpCompress/Readers/Tar/TarReader.cs b/src/SharpCompress/Readers/Tar/TarReader.cs index b14b89fc..e32bca01 100644 --- a/src/SharpCompress/Readers/Tar/TarReader.cs +++ b/src/SharpCompress/Readers/Tar/TarReader.cs @@ -69,17 +69,17 @@ namespace SharpCompress.Readers.Tar /// /// /// - public static async ValueTask OpenAsync(Stream stream, ReaderOptions? options = null) + public static async ValueTask OpenAsync(Stream stream, ReaderOptions? options = null, CancellationToken cancellationToken = default) { stream.CheckNotNull(nameof(stream)); - options = options ?? new ReaderOptions(); - RewindableStream rewindableStream = new RewindableStream(stream); + options ??= new ReaderOptions(); + RewindableStream rewindableStream = new(stream); rewindableStream.StartRecording(); - if (await GZipArchive.IsGZipFileAsync(rewindableStream)) + if (await GZipArchive.IsGZipFileAsync(rewindableStream, cancellationToken)) { rewindableStream.Rewind(false); - GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); - if (await TarArchive.IsTarFileAsync(testStream)) + GZipStream testStream = new(rewindableStream, CompressionMode.Decompress); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.GZip); @@ -88,11 +88,11 @@ namespace SharpCompress.Readers.Tar } rewindableStream.Rewind(false); - if (BZip2Stream.IsBZip2(rewindableStream)) + if (await BZip2Stream.IsBZip2Async(rewindableStream, cancellationToken)) { rewindableStream.Rewind(false); - BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false); - if (await TarArchive.IsTarFileAsync(testStream)) + BZip2Stream testStream = new(rewindableStream, CompressionMode.Decompress, false); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.BZip2); @@ -104,8 +104,8 @@ namespace SharpCompress.Readers.Tar if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); - LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress); - if (await TarArchive.IsTarFileAsync(testStream)) + LZipStream testStream = new(rewindableStream, CompressionMode.Decompress); + if (await TarArchive.IsTarFileAsync(testStream, cancellationToken)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.LZip); diff --git a/tests/SharpCompress.Test/Xz/XZHeaderTests.cs b/tests/SharpCompress.Test/Xz/XZHeaderTests.cs index 1fa2a8b5..91266fc8 100644 --- a/tests/SharpCompress.Test/Xz/XZHeaderTests.cs +++ b/tests/SharpCompress.Test/Xz/XZHeaderTests.cs @@ -1,5 +1,6 @@ using SharpCompress.Compressors.Xz; using System.IO; +using System.Threading.Tasks; using Xunit; namespace SharpCompress.Test.Xz @@ -7,35 +8,33 @@ namespace SharpCompress.Test.Xz public class XZHeaderTests : XZTestsBase { [Fact] - public void ChecksMagicNumber() + public async ValueTask ChecksMagicNumber() { var bytes = Compressed.Clone() as byte[]; bytes[3]++; - using (Stream badMagicNumberStream = new MemoryStream(bytes)) + await using (Stream badMagicNumberStream = new MemoryStream(bytes)) { - BinaryReader br = new BinaryReader(badMagicNumberStream); - var header = new XZHeader(br); - var ex = Assert.Throws(() => { header.Process(); }); + var header = new XZHeader(badMagicNumberStream); + var ex = await Assert.ThrowsAsync(async () => { await header.Process(); }); Assert.Equal("Invalid XZ Stream", ex.Message); } } [Fact] - public void CorruptHeaderThrows() + public async ValueTask CorruptHeaderThrows() { var bytes = Compressed.Clone() as byte[]; bytes[8]++; using (Stream badCrcStream = new MemoryStream(bytes)) { - BinaryReader br = new BinaryReader(badCrcStream); - var header = new XZHeader(br); - var ex = Assert.Throws(() => { header.Process(); }); + var header = new XZHeader(badCrcStream); + var ex = await Assert.ThrowsAsync(async () => { await header.Process(); }); Assert.Equal("Stream header corrupt", ex.Message); } } [Fact] - public void BadVersionIfCrcOkButStreamFlagUnknown() + public async ValueTask BadVersionIfCrcOkButStreamFlagUnknown() { var bytes = Compressed.Clone() as byte[]; byte[] streamFlags = { 0x00, 0xF4 }; @@ -44,35 +43,32 @@ namespace SharpCompress.Test.Xz crc.CopyTo(bytes, 8); using (Stream badFlagStream = new MemoryStream(bytes)) { - BinaryReader br = new BinaryReader(badFlagStream); - var header = new XZHeader(br); - var ex = Assert.Throws(() => { header.Process(); }); + var header = new XZHeader(badFlagStream); + var ex = await Assert.ThrowsAsync(async () => { await header.Process(); }); Assert.Equal("Unknown XZ Stream Version", ex.Message); } } [Fact] - public void ProcessesBlockCheckType() + public async ValueTask ProcessesBlockCheckType() { - BinaryReader br = new BinaryReader(CompressedStream); - var header = new XZHeader(br); - header.Process(); + var header = new XZHeader(CompressedStream); + await header.Process(); Assert.Equal(CheckType.CRC64, header.BlockCheckType); } [Fact] - public void CanCalculateBlockCheckSize() + public async ValueTask CanCalculateBlockCheckSize() { - BinaryReader br = new BinaryReader(CompressedStream); - var header = new XZHeader(br); - header.Process(); + var header = new XZHeader(CompressedStream); + await header.Process(); Assert.Equal(8, header.BlockCheckSize); } [Fact] - public void ProcessesStreamHeaderFromFactory() + public async ValueTask ProcessesStreamHeaderFromFactory() { - var header = XZHeader.FromStream(CompressedStream); + var header = await XZHeader.FromStream(CompressedStream); Assert.Equal(CheckType.CRC64, header.BlockCheckType); } } diff --git a/tests/SharpCompress.Test/Xz/XZStreamTests.cs b/tests/SharpCompress.Test/Xz/XZStreamTests.cs index 4b6bbaf6..1ee9558b 100644 --- a/tests/SharpCompress.Test/Xz/XZStreamTests.cs +++ b/tests/SharpCompress.Test/Xz/XZStreamTests.cs @@ -1,5 +1,6 @@ using SharpCompress.Compressors.Xz; using System.IO; +using System.Threading.Tasks; using Xunit; namespace SharpCompress.Test.Xz @@ -7,34 +8,34 @@ namespace SharpCompress.Test.Xz public class XZStreamTests : XZTestsBase { [Fact] - public void CanReadEmptyStream() + public async ValueTask CanReadEmptyStream() { XZStream xz = new XZStream(CompressedEmptyStream); using (var sr = new StreamReader(xz)) { - string uncompressed = sr.ReadToEnd(); + string uncompressed = await sr.ReadToEndAsync(); Assert.Equal(OriginalEmpty, uncompressed); } } [Fact] - public void CanReadStream() + public async ValueTask CanReadStream() { XZStream xz = new XZStream(CompressedStream); using (var sr = new StreamReader(xz)) { - string uncompressed = sr.ReadToEnd(); + string uncompressed = await sr.ReadToEndAsync(); Assert.Equal(Original, uncompressed); } } [Fact] - public void CanReadIndexedStream() + public async ValueTask CanReadIndexedStream() { XZStream xz = new XZStream(CompressedIndexedStream); using (var sr = new StreamReader(xz)) { - string uncompressed = sr.ReadToEnd(); + string uncompressed = await sr.ReadToEndAsync(); Assert.Equal(OriginalIndexed, uncompressed); } }