merge fixes and fmt

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<NotSupportedException>(() =>
                 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)

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<CryptographicException>(() => ReadAsync("Arj.encrypted.arj"));
+            var exception = await Assert.ThrowsAsync<CryptographicException>(() =>
+                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<NotSupportedException>(() =>
                 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<IEnumerable<Stream>, IAsyncReader> openReader)
+        private async Task DoMultiReaderAsync(
+            string[] archiveNames,
+            Func<IEnumerable<Stream>, 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
             {

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
                 )

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;

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())
         {

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))
         {

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())
                 {

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())
             {

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())

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",