From ec310c87de7ed03efa4d018e20638ea81bb40dcb Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Thu, 15 Jan 2026 15:20:52 +0000 Subject: [PATCH] merge fixes and fmt --- src/SharpCompress/Common/AsyncBinaryReader.cs | 9 +++- .../Zip/Headers/DirectoryEntryHeader.cs | 2 +- .../Common/Zip/Headers/LocalEntryHeader.cs | 4 +- .../Zip/Headers/Zip64DirectoryEndHeader.cs | 5 +-- .../Common/Zip/SeekableZipHeaderFactory.cs | 1 - .../Compressors/Deflate/Inflate.cs | 18 +++++--- .../Compressors/Rar/UnpackV1/Unpack.cs | 1 - src/SharpCompress/IO/BufferedSubStream.cs | 2 +- .../Ace/AceReaderAsyncTests.cs | 27 ++++++++---- .../Arj/ArjReaderAsyncTests.cs | 42 ++++++++++++++----- .../BZip2/BZip2StreamAsyncTests.cs | 2 +- .../GZip/GZipReaderAsyncTests.cs | 8 +++- .../Rar/RarArchiveAsyncTests.cs | 4 +- .../SevenZip/SevenZipArchiveAsyncTests.cs | 20 ++++++--- .../Tar/TarArchiveAsyncTests.cs | 20 +++++++-- .../Tar/TarReaderAsyncTests.cs | 2 +- .../SharpCompress.Test/Zip/Zip64AsyncTests.cs | 5 ++- .../Zip/ZipMemoryArchiveWithCrcAsyncTests.cs | 8 +++- 18 files changed, 132 insertions(+), 48 deletions(-) diff --git a/src/SharpCompress/Common/AsyncBinaryReader.cs b/src/SharpCompress/Common/AsyncBinaryReader.cs index 2b963944..8c5327ae 100644 --- a/src/SharpCompress/Common/AsyncBinaryReader.cs +++ b/src/SharpCompress/Common/AsyncBinaryReader.cs @@ -51,14 +51,19 @@ namespace SharpCompress.Common return BinaryPrimitives.ReadUInt64LittleEndian(_buffer); } - public async ValueTask ReadBytesAsync(byte[] bytes, int offset, int count, CancellationToken ct = default) + public async ValueTask ReadBytesAsync( + byte[] bytes, + int offset, + int count, + CancellationToken ct = default + ) { await _stream.ReadExactAsync(bytes, offset, count, ct).ConfigureAwait(false); } public async ValueTask SkipAsync(int count, CancellationToken ct = default) { - await _stream.SkipAsync( count, ct).ConfigureAwait(false); + await _stream.SkipAsync(count, ct).ConfigureAwait(false); } public void Dispose() diff --git a/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs b/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs index 79430b02..b19aeea5 100644 --- a/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs +++ b/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs @@ -56,7 +56,7 @@ internal class DirectoryEntryHeader : ZipFileEntry var name = new byte[nameLength]; var extra = new byte[extraLength]; var comment = new byte[commentLength]; - await reader.ReadBytesAsync(name,0 ,nameLength); + await reader.ReadBytesAsync(name, 0, nameLength); await reader.ReadBytesAsync(extra, 0, extraLength); await reader.ReadBytesAsync(comment, 0, commentLength); diff --git a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs index be33793d..d676dde0 100644 --- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs +++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs @@ -39,8 +39,8 @@ internal class LocalEntryHeader(IArchiveEncoding archiveEncoding) var extraLength = await reader.ReadUInt16Async(); var name = new byte[nameLength]; var extra = new byte[extraLength]; - await reader.ReadBytesAsync(name,0 ,nameLength); - await reader.ReadBytesAsync(extra, 0, extraLength); + await reader.ReadBytesAsync(name, 0, nameLength); + await reader.ReadBytesAsync(extra, 0, extraLength); ProcessReadData(name, extra); } diff --git a/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs b/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs index c5d5aa8a..cdd412b2 100644 --- a/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs +++ b/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs @@ -39,11 +39,10 @@ internal class Zip64DirectoryEndHeader : ZipHeader DirectorySize = (long)await reader.ReadUInt64Async(); DirectoryStartOffsetRelativeToDisk = (long)await reader.ReadUInt64Async(); var size = (int)( - SizeOfDirectoryEndRecord - - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS + SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS ); DataSector = new byte[size]; - await reader.ReadBytesAsync(DataSector, 0, size); + await reader.ReadBytesAsync(DataSector, 0, size); } private const int SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS = 44; diff --git a/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs b/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs index 6e05216b..971ffa3c 100644 --- a/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs +++ b/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs @@ -156,7 +156,6 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory } } - private static bool IsMatch(Span haystack, int position, byte[] needle) { for (var i = 0; i < needle.Length; i++) diff --git a/src/SharpCompress/Compressors/Deflate/Inflate.cs b/src/SharpCompress/Compressors/Deflate/Inflate.cs index ca00e28a..aff2c659 100644 --- a/src/SharpCompress/Compressors/Deflate/Inflate.cs +++ b/src/SharpCompress/Compressors/Deflate/Inflate.cs @@ -776,11 +776,16 @@ internal sealed class InflateBlocks // update check information if (checkfn != null) { - _codec._adler32 = check = Adler32.Calculate(check, window.Memory.Span.Slice(readAt, nBytes)); + _codec._adler32 = check = Adler32.Calculate( + check, + window.Memory.Span.Slice(readAt, nBytes) + ); } // copy as far as end of window - window.Memory.Span.Slice(readAt, nBytes).CopyTo(_codec.OutputBuffer.AsSpan(_codec.NextOut)); + window + .Memory.Span.Slice(readAt, nBytes) + .CopyTo(_codec.OutputBuffer.AsSpan(_codec.NextOut)); _codec.NextOut += nBytes; readAt += nBytes; @@ -1469,7 +1474,8 @@ internal sealed class InflateCodes } else { - s.window.Memory.Span.Slice(r, 2).CopyTo(s.window.Memory.Span.Slice(q)); + s.window.Memory.Span.Slice(r, 2) + .CopyTo(s.window.Memory.Span.Slice(q)); q += 2; r += 2; c -= 2; @@ -1497,7 +1503,8 @@ internal sealed class InflateCodes } else { - s.window.Memory.Span.Slice(r, e).CopyTo(s.window.Memory.Span.Slice(q)); + s.window.Memory.Span.Slice(r, e) + .CopyTo(s.window.Memory.Span.Slice(q)); q += e; r += e; e = 0; @@ -1516,7 +1523,8 @@ internal sealed class InflateCodes } else { - s.window.Memory.Span.Slice(r, c).CopyTo(s.window.Memory.Span.Slice(q)); + s.window.Memory.Span.Slice(r, c) + .CopyTo(s.window.Memory.Span.Slice(q)); q += c; r += c; c = 0; diff --git a/src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs b/src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs index 4f2120a7..18c2c2e3 100644 --- a/src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs +++ b/src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs @@ -126,7 +126,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack private FileHeader fileHeader; - private void Init() { if (this.window is null) diff --git a/src/SharpCompress/IO/BufferedSubStream.cs b/src/SharpCompress/IO/BufferedSubStream.cs index f5232aed..747c9776 100755 --- a/src/SharpCompress/IO/BufferedSubStream.cs +++ b/src/SharpCompress/IO/BufferedSubStream.cs @@ -38,7 +38,7 @@ internal class BufferedSubStream : SharpCompressStream, IStreamStack private int _cacheOffset; private int _cacheLength; - private readonly byte[] _cache = ArrayPool.Shared.Rent(32 << 10); + private readonly byte[] _cache = ArrayPool.Shared.Rent(32 << 10); private long origin; private long BytesLeftToRead { get; set; } diff --git a/tests/SharpCompress.Test/Ace/AceReaderAsyncTests.cs b/tests/SharpCompress.Test/Ace/AceReaderAsyncTests.cs index d42f36bc..bb8d9ed4 100644 --- a/tests/SharpCompress.Test/Ace/AceReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Ace/AceReaderAsyncTests.cs @@ -36,7 +36,10 @@ namespace SharpCompress.Test.Ace [InlineData("Ace.method1-solid.ace", CompressionType.AceLZ77)] [InlineData("Ace.method2.ace", CompressionType.AceLZ77)] [InlineData("Ace.method2-solid.ace", CompressionType.AceLZ77)] - public async ValueTask Ace_Unsupported_ShouldThrow_Async(string fileName, CompressionType compressionType) + public async ValueTask Ace_Unsupported_ShouldThrow_Async( + string fileName, + CompressionType compressionType + ) { var exception = await Assert.ThrowsAsync(() => ReadAsync(fileName, compressionType) @@ -45,7 +48,10 @@ namespace SharpCompress.Test.Ace [Theory] [InlineData("Ace.store.largefile.ace", CompressionType.None)] - public async ValueTask Ace_LargeFileTest_Read_Async(string fileName, CompressionType compressionType) + public async ValueTask Ace_LargeFileTest_Read_Async( + string fileName, + CompressionType compressionType + ) { await ReadForBufferBoundaryCheckAsync(fileName, compressionType); } @@ -62,7 +68,7 @@ namespace SharpCompress.Test.Ace { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using Stream stream = File.OpenRead(testArchive); - await using var reader = ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions() ); @@ -80,11 +86,14 @@ namespace SharpCompress.Test.Ace VerifyFiles(); } - private async Task ReadForBufferBoundaryCheckAsync(string testArchive, CompressionType expectedCompression) + private async Task ReadForBufferBoundaryCheckAsync( + string testArchive, + CompressionType expectedCompression + ) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using Stream stream = File.OpenRead(testArchive); - await using var reader = ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions() { LookForHeader = false } ); @@ -104,11 +113,15 @@ namespace SharpCompress.Test.Ace private async Task DoMultiReaderAsync(string[] archiveNames) { - var testArchives = archiveNames.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).ToList(); + var testArchives = archiveNames + .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) + .ToList(); var streams = testArchives.Select(File.OpenRead).ToList(); try { - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(streams.First())); + await using var reader = ReaderFactory.OpenAsyncReader( + new AsyncOnlyStream(streams.First()) + ); while (await reader.MoveToNextEntryAsync()) { if (!reader.Entry.IsDirectory) diff --git a/tests/SharpCompress.Test/Arj/ArjReaderAsyncTests.cs b/tests/SharpCompress.Test/Arj/ArjReaderAsyncTests.cs index 993cc781..3bd094a0 100644 --- a/tests/SharpCompress.Test/Arj/ArjReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Arj/ArjReaderAsyncTests.cs @@ -22,7 +22,8 @@ namespace SharpCompress.Test.Arj } [Fact] - public async ValueTask Arj_Uncompressed_Read_Async() => await ReadAsync("Arj.store.arj", CompressionType.None); + public async ValueTask Arj_Uncompressed_Read_Async() => + await ReadAsync("Arj.store.arj", CompressionType.None); [Fact] public async ValueTask Arj_Method1_Read_Async() => await ReadAsync("Arj.method1.arj"); @@ -39,7 +40,9 @@ namespace SharpCompress.Test.Arj [Fact] public async ValueTask Arj_Encrypted_Read_Async() { - var exception = await Assert.ThrowsAsync(() => ReadAsync("Arj.encrypted.arj")); + var exception = await Assert.ThrowsAsync(() => + ReadAsync("Arj.encrypted.arj") + ); } [Fact] @@ -55,7 +58,7 @@ namespace SharpCompress.Test.Arj "Arj.store.split.a04", "Arj.store.split.a05", ], - streams => ReaderFactory.OpenAsync(new AsyncOnlyStream(streams.First())) + streams => ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(streams.First())) ) ); } @@ -64,7 +67,10 @@ namespace SharpCompress.Test.Arj [InlineData("Arj.method1.largefile.arj", CompressionType.ArjLZ77)] [InlineData("Arj.method2.largefile.arj", CompressionType.ArjLZ77)] [InlineData("Arj.method3.largefile.arj", CompressionType.ArjLZ77)] - public async ValueTask Arj_LargeFile_ShouldThrow_Async(string fileName, CompressionType compressionType) + public async ValueTask Arj_LargeFile_ShouldThrow_Async( + string fileName, + CompressionType compressionType + ) { var exception = await Assert.ThrowsAsync(() => ReadForBufferBoundaryCheckAsync(fileName, compressionType) @@ -74,16 +80,22 @@ namespace SharpCompress.Test.Arj [Theory] [InlineData("Arj.store.largefile.arj", CompressionType.None)] [InlineData("Arj.method4.largefile.arj", CompressionType.ArjLZ77)] - public async ValueTask Arj_LargeFileTest_Read_Async(string fileName, CompressionType compressionType) + public async ValueTask Arj_LargeFileTest_Read_Async( + string fileName, + CompressionType compressionType + ) { await ReadForBufferBoundaryCheckAsync(fileName, compressionType); } - private async Task ReadAsync(string testArchive, CompressionType? expectedCompression = null) + private async Task ReadAsync( + string testArchive, + CompressionType? expectedCompression = null + ) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using Stream stream = File.OpenRead(testArchive); - await using var reader = ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions() ); @@ -104,11 +116,14 @@ namespace SharpCompress.Test.Arj VerifyFiles(); } - private async Task ReadForBufferBoundaryCheckAsync(string testArchive, CompressionType expectedCompression) + private async Task ReadForBufferBoundaryCheckAsync( + string testArchive, + CompressionType expectedCompression + ) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using Stream stream = File.OpenRead(testArchive); - await using var reader = ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions() { LookForHeader = false } ); @@ -126,9 +141,14 @@ namespace SharpCompress.Test.Arj VerifyFiles(); } - private async Task DoMultiReaderAsync(string[] archiveNames, Func, IAsyncReader> openReader) + private async Task DoMultiReaderAsync( + string[] archiveNames, + Func, IAsyncReader> openReader + ) { - var testArchives = archiveNames.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).ToList(); + var testArchives = archiveNames + .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) + .ToList(); var streams = testArchives.Select(File.OpenRead).ToList(); try { diff --git a/tests/SharpCompress.Test/BZip2/BZip2StreamAsyncTests.cs b/tests/SharpCompress.Test/BZip2/BZip2StreamAsyncTests.cs index 5ccfde90..bde34a14 100644 --- a/tests/SharpCompress.Test/BZip2/BZip2StreamAsyncTests.cs +++ b/tests/SharpCompress.Test/BZip2/BZip2StreamAsyncTests.cs @@ -33,7 +33,7 @@ public class BZip2StreamAsyncTests { using ( var bzip2Stream = new BZip2Stream( - new AsyncOnlyStream(memoryStream), + new AsyncOnlyStream(memoryStream), SharpCompress.Compressors.CompressionMode.Compress, false ) diff --git a/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs b/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs index c9e879e6..8f821805 100644 --- a/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs @@ -70,7 +70,13 @@ public class GZipReaderAsyncTests : ReaderTests bufferSize: options.BufferSize ); using var testStream = new TestStream(protectedStream); - await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(testStream), options, default)) + await using ( + var reader = ReaderFactory.OpenAsyncReader( + new AsyncOnlyStream(testStream), + options, + default + ) + ) { await UseReaderAsync(reader, expectedCompression); protectedStream.ThrowOnDispose = false; diff --git a/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs b/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs index 44d0a400..479a5655 100644 --- a/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs @@ -654,7 +654,9 @@ public class RarArchiveAsyncTests : ArchiveTests { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = await ArchiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream) + ); Assert.True(await archive.IsSolidAsync()); await using (var reader = await archive.ExtractAllEntriesAsync()) { diff --git a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs index 6c571ea1..31e8bf74 100644 --- a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs @@ -17,7 +17,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA.7z"); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = await ArchiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream) + ); await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) { @@ -42,7 +44,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA2.7z"); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = await ArchiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream) + ); await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) { @@ -67,7 +71,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.solid.7z"); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = await ArchiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream) + ); await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) { @@ -92,7 +98,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.BZip2.7z"); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = await ArchiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream) + ); await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) { @@ -117,7 +125,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.PPMd.7z"); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = await ArchiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream) + ); await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) { diff --git a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs index 2a13bb4f..5a12507c 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs @@ -33,7 +33,13 @@ public class TarArchiveAsyncTests : ArchiveTests // Step 1: create a tar file containing a file with the test name using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive))) - using (var writer = WriterFactory.OpenAsync(new AsyncOnlyStream(stream), ArchiveType.Tar, CompressionType.None)) + using ( + var writer = WriterFactory.OpenAsyncWriter( + new AsyncOnlyStream(stream), + ArchiveType.Tar, + CompressionType.None + ) + ) using (Stream inputStream = new MemoryStream()) { var sw = new StreamWriter(inputStream); @@ -84,7 +90,13 @@ public class TarArchiveAsyncTests : ArchiveTests // Step 1: create a tar file containing a file with a long name using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive))) - using (var writer = WriterFactory.OpenAsync(new AsyncOnlyStream(stream), ArchiveType.Tar, CompressionType.None)) + using ( + var writer = WriterFactory.OpenAsyncWriter( + new AsyncOnlyStream(stream), + ArchiveType.Tar, + CompressionType.None + ) + ) using (Stream inputStream = new MemoryStream()) { var sw = new StreamWriter(inputStream); @@ -187,7 +199,9 @@ public class TarArchiveAsyncTests : ArchiveTests using (var inputMemory = new MemoryStream(mstm.ToArray())) { var tropt = new ReaderOptions { ArchiveEncoding = enc }; - await using (var tr = ReaderFactory.OpenAsync(new AsyncOnlyStream(inputMemory), tropt)) + await using ( + var tr = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(inputMemory), tropt) + ) { while (await tr.MoveToNextEntryAsync()) { diff --git a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs index 37578381..2f92fe3a 100644 --- a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs @@ -73,7 +73,7 @@ public class TarReaderAsyncTests : ReaderTests public async ValueTask Tar_BZip2_Entry_Stream_Async() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.bz2"))) - await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream))) + await using (var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream))) { while (await reader.MoveToNextEntryAsync()) { diff --git a/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs b/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs index 82a096c3..cd9fe18d 100644 --- a/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs @@ -199,7 +199,10 @@ public class Zip64AsyncTests : WriterTests ZipEntry? prev = null; using (var fs = File.OpenRead(filename)) { - var rd = ReaderFactory.OpenAsync(new AsyncOnlyStream(fs), new ReaderOptions { LookForHeader = false }); + var rd = ReaderFactory.OpenAsyncReader( + new AsyncOnlyStream(fs), + new ReaderOptions { LookForHeader = false } + ); await using (rd) { while (await rd.MoveToNextEntryAsync()) diff --git a/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs index dec05c40..c57d5026 100644 --- a/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs @@ -132,7 +132,13 @@ public class ZipTypesLevelsWithCrcRatioAsyncTests : ArchiveTests CompressionLevel = compressionLevel, }; - using (var writer = WriterFactory.OpenAsync(new AsyncOnlyStream(zipStream), ArchiveType.Zip, writerOptions)) + using ( + var writer = WriterFactory.OpenAsyncWriter( + new AsyncOnlyStream(zipStream), + ArchiveType.Zip, + writerOptions + ) + ) { await writer.WriteAsync( $"{compressionType}_level_{compressionLevel}_{sizeMb}MiB.txt",