Fix async test failures after xunit v3 upgrade

src/SharpCompress/Readers/ReaderFactory.cs

@@ -24,7 +24,7 @@ public static IReader OpenReader(string filePath, ReaderOptions? options = null)
     /// <param name="options"></param>
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    public static IAsyncReader OpenAsyncReader(
+    public static ValueTask<IAsyncReader> OpenAsyncReader(
         string filePath,
         ReaderOptions? options = null,
         CancellationToken cancellationToken = default
@@ -47,7 +47,7 @@ public static IReader OpenReader(FileInfo fileInfo, ReaderOptions? options = nul
     /// <param name="options"></param>
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    public static IAsyncReader OpenAsyncReader(
+    public static ValueTask<IAsyncReader> OpenAsyncReader(
         FileInfo fileInfo,
         ReaderOptions? options = null,
         CancellationToken cancellationToken = default
@@ -110,7 +110,7 @@ public static IReader OpenReader(Stream stream, ReaderOptions? options = null)
         );
     }
 
-    public static IAsyncReader OpenAsyncReader(
+    public static async ValueTask<IAsyncReader> OpenAsyncReader(
         Stream stream,
         ReaderOptions? options = null,
         CancellationToken cancellationToken = default
@@ -136,7 +136,12 @@ public static IAsyncReader OpenAsyncReader(
             if (testedFactory is IReaderFactory readerFactory)
             {
                 ((IStreamStack)bStream).StackSeek(pos);
-                if (testedFactory.IsArchive(bStream))
+                if (
+                    await testedFactory.IsArchiveAsync(
+                        bStream,
+                        cancellationToken: cancellationToken
+                    )
+                )
                 {
                     ((IStreamStack)bStream).StackSeek(pos);
                     return readerFactory.OpenAsyncReader(bStream, options, cancellationToken);
@@ -152,7 +157,10 @@ public static IAsyncReader OpenAsyncReader(
                 continue; // Already tested above
             }
             ((IStreamStack)bStream).StackSeek(pos);
-            if (factory is IReaderFactory readerFactory && factory.IsArchive(bStream))
+            if (
+                factory is IReaderFactory readerFactory
+                && await factory.IsArchiveAsync(bStream, cancellationToken: cancellationToken)
+            )
             {
                 ((IStreamStack)bStream).StackSeek(pos);
                 return readerFactory.OpenAsyncReader(bStream, options, cancellationToken);

tests/SharpCompress.Test/Ace/AceReaderAsyncTests.cs

@@ -68,7 +68,7 @@ private async Task ReadAsync(string testArchive, CompressionType expectedCompres
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
             using Stream stream = File.OpenRead(testArchive);
-            await using var reader = ReaderFactory.OpenAsyncReader(
+            await using var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(stream),
                 new ReaderOptions()
             );
@@ -93,7 +93,7 @@ CompressionType expectedCompression
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
             using Stream stream = File.OpenRead(testArchive);
-            await using var reader = ReaderFactory.OpenAsyncReader(
+            await using var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(stream),
                 new ReaderOptions() { LookForHeader = false }
             );
@@ -119,7 +119,7 @@ private async Task DoMultiReaderAsync(string[] archiveNames)
             var streams = testArchives.Select(File.OpenRead).ToList();
             try
             {
-                await using var reader = ReaderFactory.OpenAsyncReader(
+                await using var reader = await ReaderFactory.OpenAsyncReader(
                     new AsyncOnlyStream(streams.First())
                 );
                 while (await reader.MoveToNextEntryAsync())

tests/SharpCompress.Test/Arj/ArjReaderAsyncTests.cs

@@ -95,7 +95,7 @@ private async Task ReadAsync(
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
             using Stream stream = File.OpenRead(testArchive);
-            await using var reader = ReaderFactory.OpenAsyncReader(
+            await using var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(stream),
                 new ReaderOptions()
             );
@@ -123,7 +123,7 @@ CompressionType expectedCompression
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
             using Stream stream = File.OpenRead(testArchive);
-            await using var reader = ReaderFactory.OpenAsyncReader(
+            await using var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(stream),
                 new ReaderOptions() { LookForHeader = false }
             );
@@ -143,7 +143,7 @@ await reader.WriteEntryToDirectoryAsync(
 
         private async Task DoMultiReaderAsync(
             string[] archiveNames,
-            Func<IEnumerable<Stream>, IAsyncReader> openReader
+            Func<IEnumerable<Stream>, ValueTask<IAsyncReader>> openReader
         )
         {
             var testArchives = archiveNames
@@ -152,7 +152,7 @@ Func<IEnumerable<Stream>, IAsyncReader> openReader
             var streams = testArchives.Select(File.OpenRead).ToList();
             try
             {
-                await using var reader = openReader(streams);
+                await using var reader = await openReader(streams);
                 while (await reader.MoveToNextEntryAsync())
                 {
                     if (!reader.Entry.IsDirectory)

tests/SharpCompress.Test/GZip/AsyncTests.cs

@@ -26,7 +26,7 @@ public async ValueTask Reader_Async_Extract_All()
 #else
         await using var stream = File.OpenRead(testArchive);
 #endif
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
 
         await reader.WriteAllToDirectoryAsync(
             SCRATCH_FILES_PATH,
@@ -51,7 +51,7 @@ public async ValueTask Reader_Async_Extract_Single_Entry()
 #else
         await using var stream = File.OpenRead(testArchive);
 #endif
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
 
         while (await reader.MoveToNextEntryAsync())
         {
@@ -141,7 +141,7 @@ public async ValueTask Async_With_Cancellation_Token()
 #else
         await using var stream = File.OpenRead(testArchive);
 #endif
-        await using var reader = ReaderFactory.OpenAsyncReader(
+        await using var reader = await ReaderFactory.OpenAsyncReader(
             new AsyncOnlyStream(stream),
             cancellationToken: cts.Token
         );
@@ -195,7 +195,7 @@ public async ValueTask EntryStream_ReadAsync_Works()
 #else
         await using var stream = File.OpenRead(testArchive);
 #endif
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
 
         while (await reader.MoveToNextEntryAsync())
         {

tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs

@@ -22,7 +22,7 @@ public async ValueTask GZip_Reader_Generic2_Async()
     {
         //read only as GZip item
         using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"));
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
         while (await reader.MoveToNextEntryAsync())
         {
             Assert.NotEqual(0, reader.Entry.Size);
@@ -71,7 +71,7 @@ ReaderOptions options
         );
         using var testStream = new TestStream(protectedStream);
         await using (
-            var reader = ReaderFactory.OpenAsyncReader(
+            var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(testStream),
                 options,
                 default

tests/SharpCompress.Test/ProgressReportTests.cs

@@ -541,7 +541,7 @@ public async ValueTask Zip_ReadAsync_ReportsProgress()
         var readerOptions = new ReaderOptions { Progress = progress };
 
         await using (
-            var reader = ReaderFactory.OpenAsyncReader(
+            var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(archiveStream),
                 readerOptions
             )

tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs

@@ -208,7 +208,7 @@ await ReadAsync(
     private async ValueTask DoRar_Entry_Stream_Async(string filename)
     {
         using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)))
-        await using (var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)))
+        await using (var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)))
         {
             while (await reader.MoveToNextEntryAsync())
             {
@@ -253,7 +253,7 @@ public async ValueTask Rar_Reader_Audio_program_Async()
             var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.Audio_program.rar"))
         )
         await using (
-            var reader = ReaderFactory.OpenAsyncReader(
+            var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(stream),
                 new ReaderOptions { LookForHeader = true }
             )
@@ -325,7 +325,7 @@ public async ValueTask Rar5_Solid_Skip_Reader_Async() =>
     private async ValueTask DoRar_Solid_Skip_Reader_Async(string filename)
     {
         using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename));
-        await using var reader = ReaderFactory.OpenAsyncReader(
+        await using var reader = await ReaderFactory.OpenAsyncReader(
             new AsyncOnlyStream(stream),
             new ReaderOptions { LookForHeader = true }
         );
@@ -351,7 +351,7 @@ await reader.WriteEntryToDirectoryAsync(
     private async ValueTask DoRar_Reader_Skip_Async(string filename)
     {
         using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename));
-        await using var reader = ReaderFactory.OpenAsyncReader(
+        await using var reader = await ReaderFactory.OpenAsyncReader(
             new AsyncOnlyStream(stream),
             new ReaderOptions { LookForHeader = true }
         );
@@ -376,7 +376,7 @@ private async ValueTask ReadAsync(
     {
         testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
         using Stream stream = File.OpenRead(testArchive);
-        await using var reader = ReaderFactory.OpenAsyncReader(
+        await using var reader = await ReaderFactory.OpenAsyncReader(
             new AsyncOnlyStream(stream),
             readerOptions ?? new ReaderOptions()
         );

tests/SharpCompress.Test/ReaderTests.cs

@@ -146,7 +146,7 @@ private async ValueTask ReadImplAsync(
         );
         using var testStream = new TestStream(protectedStream);
         await using (
-            var reader = ReaderFactory.OpenAsyncReader(
+            var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(testStream),
                 options,
                 cancellationToken

tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs

@@ -200,7 +200,10 @@ public async ValueTask Tar_Japanese_Name_Async(int length)
         {
             var tropt = new ReaderOptions { ArchiveEncoding = enc };
             await using (
-                var tr = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(inputMemory), tropt)
+                var tr = await ReaderFactory.OpenAsyncReader(
+                    new AsyncOnlyStream(inputMemory),
+                    tropt
+                )
             )
             {
                 while (await tr.MoveToNextEntryAsync())

tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs

@@ -23,7 +23,7 @@ public async ValueTask Tar_Skip_Async()
         using Stream stream = new ForwardOnlyStream(
             File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"))
         );
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
         var x = 0;
         while (await reader.MoveToNextEntryAsync())
         {
@@ -73,7 +73,7 @@ public async ValueTask Tar_GZip_OldGnu_Reader_Async() =>
     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.OpenAsyncReader(new AsyncOnlyStream(stream)))
+        await using (var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)))
         {
             while (await reader.MoveToNextEntryAsync())
             {
@@ -184,7 +184,7 @@ public async ValueTask Tar_Broken_Stream_Async()
     {
         var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar");
         using Stream stream = File.OpenRead(archiveFullPath);
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
         var memoryStream = new MemoryStream();
 
         Assert.True(await reader.MoveToNextEntryAsync());
@@ -201,7 +201,7 @@ public async ValueTask Tar_Corrupted_Async()
     {
         var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "TarCorrupted.tar");
         using Stream stream = File.OpenRead(archiveFullPath);
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
         var memoryStream = new MemoryStream();
 
         Assert.True(await reader.MoveToNextEntryAsync());
@@ -220,7 +220,7 @@ public async ValueTask Tar_GZip_With_Symlink_Entries_Async()
         using Stream stream = File.OpenRead(
             Path.Combine(TEST_ARCHIVES_PATH, "TarWithSymlink.tar.gz")
         );
-        await using var reader = ReaderFactory.OpenAsyncReader(
+        await using var reader = await ReaderFactory.OpenAsyncReader(
             new AsyncOnlyStream(stream),
             new ReaderOptions { LookForHeader = true }
         );

tests/SharpCompress.Test/WriterTests.cs

@@ -92,7 +92,7 @@ await writer.WriteAllAsync(
 
             readerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default;
 
-            await using var reader = ReaderFactory.OpenAsyncReader(
+            await using var reader = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(SharpCompressStream.Create(stream, leaveOpen: true)),
                 readerOptions,
                 cancellationToken

tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs

@@ -199,7 +199,7 @@ public async ValueTask<Tuple<long, long>> ReadForwardOnlyAsync(string filename)
         ZipEntry? prev = null;
         using (var fs = File.OpenRead(filename))
         {
-            var rd = ReaderFactory.OpenAsyncReader(
+            var rd = await ReaderFactory.OpenAsyncReader(
                 new AsyncOnlyStream(fs),
                 new ReaderOptions { LookForHeader = false }
             );

tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs

@@ -20,7 +20,7 @@ public async ValueTask Issue_269_Double_Skip_Async()
     {
         var path = Path.Combine(TEST_ARCHIVES_PATH, "PrePostHeaders.zip");
         using Stream stream = new ForwardOnlyStream(File.OpenRead(path));
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
         var count = 0;
         while (await reader.MoveToNextEntryAsync())
         {
@@ -65,7 +65,7 @@ public async ValueTask Zip_Deflate_Streamed_Skip_Async()
         using Stream stream = new ForwardOnlyStream(
             File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))
         );
-        await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
+        await using var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream));
         var x = 0;
         while (await reader.MoveToNextEntryAsync())
         {
@@ -150,7 +150,7 @@ public async ValueTask Zip_Reader_Disposal_Test_Async()
         using var stream = new TestStream(
             File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))
         );
-        await using (var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)))
+        await using (var reader = await ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)))
         {
             while (await reader.MoveToNextEntryAsync())
             {
@@ -174,7 +174,7 @@ public async ValueTask Zip_Reader_Disposal_Test2_Async()
                 File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))
             )
         );
-        await using var reader = ReaderFactory.OpenAsyncReader(stream);
+        await using var reader = await ReaderFactory.OpenAsyncReader(stream);
         while (await reader.MoveToNextEntryAsync())
         {
             if (!reader.Entry.IsDirectory)