From 9cf8a3dbbe97db981494d0a2cac709a969023e7a Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Sat, 6 Feb 2021 09:08:09 +0000 Subject: [PATCH] more awaits --- src/SharpCompress/Archives/ArchiveFactory.cs | 50 +++--- .../Archives/IArchiveEntryExtensions.cs | 37 ++-- .../Archives/IArchiveExtensions.cs | 10 +- src/SharpCompress/Archives/Zip/ZipArchive.cs | 30 ++-- .../Readers/IReaderExtensions.cs | 2 +- src/SharpCompress/Readers/ReaderFactory.cs | 59 +++---- src/SharpCompress/Writers/AbstractWriter.cs | 2 +- src/SharpCompress/Writers/GZip/GZipWriter.cs | 4 +- src/SharpCompress/Writers/IWriter.cs | 2 +- .../Writers/IWriterExtensions.cs | 18 +- src/SharpCompress/Writers/WriterFactory.cs | 9 +- src/SharpCompress/Writers/Zip/ZipWriter.cs | 41 ++--- tests/SharpCompress.Test/ArchiveTests.cs | 43 ++--- .../GZip/GZipArchiveTests.cs | 22 +-- .../GZip/GZipReaderTests.cs | 11 +- .../GZip/GZipWriterTests.cs | 20 +-- tests/SharpCompress.Test/ReaderTests.cs | 21 +-- tests/SharpCompress.Test/TestBase.cs | 13 +- tests/SharpCompress.Test/WriterTests.cs | 8 +- tests/SharpCompress.Test/Zip/Zip64Tests.cs | 20 +-- .../SharpCompress.Test/Zip/ZipArchiveTests.cs | 160 +++++++++--------- .../SharpCompress.Test/Zip/ZipReaderTests.cs | 136 +++++++-------- 22 files changed, 368 insertions(+), 350 deletions(-) diff --git a/src/SharpCompress/Archives/ArchiveFactory.cs b/src/SharpCompress/Archives/ArchiveFactory.cs index c0f8c389..a48eac8c 100644 --- a/src/SharpCompress/Archives/ArchiveFactory.cs +++ b/src/SharpCompress/Archives/ArchiveFactory.cs @@ -1,9 +1,11 @@ using System; using System.IO; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Archives.GZip; -using SharpCompress.Archives.Rar; -using SharpCompress.Archives.SevenZip; -using SharpCompress.Archives.Tar; +//using SharpCompress.Archives.Rar; +//using SharpCompress.Archives.SevenZip; +//using SharpCompress.Archives.Tar; using SharpCompress.Archives.Zip; using SharpCompress.Common; using SharpCompress.Readers; @@ -18,7 +20,7 @@ namespace SharpCompress.Archives /// /// /// - public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null) + public static async ValueTask OpenAsync(Stream stream, ReaderOptions? readerOptions = null) { stream.CheckNotNull(nameof(stream)); if (!stream.CanRead || !stream.CanSeek) @@ -26,25 +28,25 @@ namespace SharpCompress.Archives throw new ArgumentException("Stream should be readable and seekable"); } readerOptions ??= new ReaderOptions(); - if (ZipArchive.IsZipFile(stream, null)) + if (await ZipArchive.IsZipFileAsync(stream, null)) { stream.Seek(0, SeekOrigin.Begin); return ZipArchive.Open(stream, readerOptions); } stream.Seek(0, SeekOrigin.Begin); - if (SevenZipArchive.IsSevenZipFile(stream)) + /*if (SevenZipArchive.IsSevenZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return SevenZipArchive.Open(stream, readerOptions); } - stream.Seek(0, SeekOrigin.Begin); + stream.Seek(0, SeekOrigin.Begin); */ if (GZipArchive.IsGZipFile(stream)) { stream.Seek(0, SeekOrigin.Begin); return GZipArchive.Open(stream, readerOptions); } stream.Seek(0, SeekOrigin.Begin); - if (RarArchive.IsRarFile(stream, readerOptions)) + /* if (RarArchive.IsRarFile(stream, readerOptions)) { stream.Seek(0, SeekOrigin.Begin); return RarArchive.Open(stream, readerOptions); @@ -54,7 +56,7 @@ namespace SharpCompress.Archives { stream.Seek(0, SeekOrigin.Begin); return TarArchive.Open(stream, readerOptions); - } + } */ throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip"); } @@ -63,7 +65,7 @@ namespace SharpCompress.Archives return type switch { ArchiveType.Zip => ZipArchive.Create(), - ArchiveType.Tar => TarArchive.Create(), + //ArchiveType.Tar => TarArchive.Create(), ArchiveType.GZip => GZipArchive.Create(), _ => throw new NotSupportedException("Cannot create Archives of type: " + type) }; @@ -74,10 +76,10 @@ namespace SharpCompress.Archives /// /// /// - public static IArchive Open(string filePath, ReaderOptions? options = null) + public static ValueTask OpenAsync(string filePath, ReaderOptions? options = null) { filePath.CheckNotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), options); + return OpenAsync(new FileInfo(filePath), options); } /// @@ -85,28 +87,28 @@ namespace SharpCompress.Archives /// /// /// - public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null) + public static async ValueTask OpenAsync(FileInfo fileInfo, ReaderOptions? options = null) { fileInfo.CheckNotNull(nameof(fileInfo)); options ??= new ReaderOptions { LeaveStreamOpen = false }; - using var stream = fileInfo.OpenRead(); - if (ZipArchive.IsZipFile(stream, null)) + await using var stream = fileInfo.OpenRead(); + if (await ZipArchive.IsZipFileAsync(stream, null)) { return ZipArchive.Open(fileInfo, options); } stream.Seek(0, SeekOrigin.Begin); - if (SevenZipArchive.IsSevenZipFile(stream)) + /*if (SevenZipArchive.IsSevenZipFile(stream)) { return SevenZipArchive.Open(fileInfo, options); } - stream.Seek(0, SeekOrigin.Begin); + stream.Seek(0, SeekOrigin.Begin); */ if (GZipArchive.IsGZipFile(stream)) { return GZipArchive.Open(fileInfo, options); } stream.Seek(0, SeekOrigin.Begin); - if (RarArchive.IsRarFile(stream, options)) + /*if (RarArchive.IsRarFile(stream, options)) { return RarArchive.Open(fileInfo, options); } @@ -114,20 +116,22 @@ namespace SharpCompress.Archives if (TarArchive.IsTarFile(stream)) { return TarArchive.Open(fileInfo, options); - } + } */ throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip"); } /// /// Extract to specific directory, retaining filename /// - public static void WriteToDirectory(string sourceArchive, string destinationDirectory, - ExtractionOptions? options = null) + public static async ValueTask WriteToDirectory(string sourceArchive, + string destinationDirectory, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default) { - using IArchive archive = Open(sourceArchive); + using IArchive archive = await OpenAsync(sourceArchive); foreach (IArchiveEntry entry in archive.Entries) { - entry.WriteToDirectory(destinationDirectory, options); + await entry.WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken); } } } diff --git a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs index 829b8bbd..0349d451 100644 --- a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs +++ b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs @@ -1,4 +1,6 @@ using System.IO; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.IO; @@ -6,7 +8,7 @@ namespace SharpCompress.Archives { public static class IArchiveEntryExtensions { - public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo) + public static async ValueTask WriteToAsync(this IArchiveEntry archiveEntry, Stream streamToWriteTo, CancellationToken cancellationToken = default) { if (archiveEntry.IsDirectory) { @@ -22,11 +24,11 @@ namespace SharpCompress.Archives { return; } - using (entryStream) + await using (entryStream) { - using (Stream s = new ListeningStream(streamListener, entryStream)) + await using (Stream s = new ListeningStream(streamListener, entryStream)) { - s.TransferTo(streamToWriteTo); + await s.TransferToAsync(streamToWriteTo, cancellationToken); } } streamListener.FireEntryExtractionEnd(archiveEntry); @@ -35,29 +37,30 @@ namespace SharpCompress.Archives /// /// Extract to specific directory, retaining filename /// - public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory, - ExtractionOptions? options = null) + public static ValueTask WriteEntryToDirectoryAsync(this IArchiveEntry entry, + string destinationDirectory, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default) { - ExtractionMethods.WriteEntryToDirectory(entry, destinationDirectory, options, - entry.WriteToFile); + return ExtractionMethods.WriteEntryToDirectoryAsync(entry, destinationDirectory, options, + entry.WriteToFileAsync, cancellationToken); } /// /// Extract to specific file /// - public static void WriteToFile(this IArchiveEntry entry, + public static ValueTask WriteToFileAsync(this IArchiveEntry entry, string destinationFileName, - ExtractionOptions? options = null) + ExtractionOptions? options = null, + CancellationToken cancellationToken = default) { - ExtractionMethods.WriteEntryToFile(entry, destinationFileName, options, - (x, fm) => + return ExtractionMethods.WriteEntryToFileAsync(entry, destinationFileName, options, + async (x, fm, ct) => { - using (FileStream fs = File.Open(destinationFileName, fm)) - { - entry.WriteTo(fs); - } - }); + await using FileStream fs = File.Open(x, fm); + await entry.WriteToAsync(fs, ct); + }, cancellationToken); } } } \ No newline at end of file diff --git a/src/SharpCompress/Archives/IArchiveExtensions.cs b/src/SharpCompress/Archives/IArchiveExtensions.cs index 23b8a27e..bab30de9 100644 --- a/src/SharpCompress/Archives/IArchiveExtensions.cs +++ b/src/SharpCompress/Archives/IArchiveExtensions.cs @@ -1,4 +1,6 @@ using System.Linq; +using System.Threading; +using System.Threading.Tasks; using SharpCompress.Common; namespace SharpCompress.Archives @@ -8,12 +10,14 @@ namespace SharpCompress.Archives /// /// Extract to specific directory, retaining filename /// - public static void WriteToDirectory(this IArchive archive, string destinationDirectory, - ExtractionOptions? options = null) + public static async ValueTask WriteToDirectoryAsync(this IArchive archive, + string destinationDirectory, + ExtractionOptions? options = null, + CancellationToken cancellationToken = default) { foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory)) { - entry.WriteToDirectory(destinationDirectory, options); + await entry.WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken); } } } diff --git a/src/SharpCompress/Archives/Zip/ZipArchive.cs b/src/SharpCompress/Archives/Zip/ZipArchive.cs index c3362eff..6604e301 100644 --- a/src/SharpCompress/Archives/Zip/ZipArchive.cs +++ b/src/SharpCompress/Archives/Zip/ZipArchive.cs @@ -60,29 +60,37 @@ namespace SharpCompress.Archives.Zip return new ZipArchive(stream, readerOptions ?? new ReaderOptions()); } - public static bool IsZipFile(string filePath, string? password = null) + public static ValueTask IsZipFile(string filePath, string? password = null) { - return IsZipFile(new FileInfo(filePath), password); + return IsZipFileAsync(new FileInfo(filePath), password); } - public static bool IsZipFile(FileInfo fileInfo, string? password = null) + public static async ValueTask IsZipFileAsync(FileInfo fileInfo, string? password = null) { if (!fileInfo.Exists) { return false; } - using (Stream stream = fileInfo.OpenRead()) - { - return IsZipFile(stream, password); - } + + await using Stream stream = fileInfo.OpenRead(); + return await IsZipFileAsync(stream, password); } - public static bool IsZipFile(Stream stream, string? password = null) + public static async ValueTask IsZipFileAsync(Stream stream, string? password = null) { - StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding()); + StreamingZipHeaderFactory headerFactory = new(password, new ArchiveEncoding()); try { - ZipHeader? header = headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split); + var headers = headerFactory.ReadStreamHeader(stream); + ZipHeader? header = null; + await foreach (ZipHeader zipHeader in headers) + { + if (zipHeader.ZipHeaderType == ZipHeaderType.Split) + { + header = zipHeader; + break; + } + } if (header is null) { return false; @@ -196,7 +204,7 @@ namespace SharpCompress.Archives.Zip public static ZipArchive Create() { - return new ZipArchive(); + return new(); } protected override IReader CreateReaderForSolidExtraction() diff --git a/src/SharpCompress/Readers/IReaderExtensions.cs b/src/SharpCompress/Readers/IReaderExtensions.cs index 60d32798..19eee92d 100644 --- a/src/SharpCompress/Readers/IReaderExtensions.cs +++ b/src/SharpCompress/Readers/IReaderExtensions.cs @@ -14,7 +14,7 @@ namespace SharpCompress.Readers await reader.WriteEntryToAsync(stream); } - public static async ValueTask WriteEntryTo(this IReader reader, FileInfo filePath) + public static async ValueTask WriteEntryToAsync(this IReader reader, FileInfo filePath) { await using Stream stream = filePath.Open(FileMode.Create); await reader.WriteEntryToAsync(stream); diff --git a/src/SharpCompress/Readers/ReaderFactory.cs b/src/SharpCompress/Readers/ReaderFactory.cs index 1384264f..0abdc06b 100644 --- a/src/SharpCompress/Readers/ReaderFactory.cs +++ b/src/SharpCompress/Readers/ReaderFactory.cs @@ -1,8 +1,9 @@ using System; using System.IO; +using System.Threading.Tasks; using SharpCompress.Archives.GZip; -using SharpCompress.Archives.Rar; -using SharpCompress.Archives.Tar; +//using SharpCompress.Archives.Rar; +//using SharpCompress.Archives.Tar; using SharpCompress.Archives.Zip; using SharpCompress.Common; using SharpCompress.Compressors; @@ -10,8 +11,8 @@ using SharpCompress.Compressors.BZip2; using SharpCompress.Compressors.Deflate; using SharpCompress.IO; using SharpCompress.Readers.GZip; -using SharpCompress.Readers.Rar; -using SharpCompress.Readers.Tar; +//using SharpCompress.Readers.Rar; +//using SharpCompress.Readers.Tar; using SharpCompress.Readers.Zip; using SharpCompress.Compressors.LZMA; using SharpCompress.Compressors.Xz; @@ -26,16 +27,16 @@ namespace SharpCompress.Readers /// /// /// - public static IReader Open(Stream stream, ReaderOptions? options = null) + public static async ValueTask OpenAsync(Stream stream, ReaderOptions? options = null) { stream.CheckNotNull(nameof(stream)); - options = options ?? new ReaderOptions() - { - LeaveStreamOpen = false - }; - RewindableStream rewindableStream = new RewindableStream(stream); + options ??= new ReaderOptions() + { + LeaveStreamOpen = false + }; + RewindableStream rewindableStream = new(stream); rewindableStream.StartRecording(); - if (ZipArchive.IsZipFile(rewindableStream, options.Password)) + if (await ZipArchive.IsZipFileAsync(rewindableStream, options.Password)) { rewindableStream.Rewind(true); return ZipReader.Open(rewindableStream, options); @@ -44,12 +45,12 @@ namespace SharpCompress.Readers if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); - GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); + /*GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.GZip); - } + } */ rewindableStream.Rewind(true); return GZipReader.Open(rewindableStream, options); } @@ -58,27 +59,27 @@ namespace SharpCompress.Readers if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); - BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false); + /*BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, options, CompressionType.BZip2); - } + } */ } rewindableStream.Rewind(false); if (LZipStream.IsLZipFile(rewindableStream)) { rewindableStream.Rewind(false); - LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress); - if (TarArchive.IsTarFile(testStream)) - { - rewindableStream.Rewind(true); - return new TarReader(rewindableStream, options, CompressionType.LZip); - } + /* LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress); + if (TarArchive.IsTarFile(testStream)) + { + rewindableStream.Rewind(true); + return new TarReader(rewindableStream, options, CompressionType.LZip); + } */ } rewindableStream.Rewind(false); - if (RarArchive.IsRarFile(rewindableStream, options)) + /* if (RarArchive.IsRarFile(rewindableStream, options)) { rewindableStream.Rewind(true); return RarReader.Open(rewindableStream, options); @@ -89,17 +90,17 @@ namespace SharpCompress.Readers { rewindableStream.Rewind(true); return TarReader.Open(rewindableStream, options); - } + } */ rewindableStream.Rewind(false); if (XZStream.IsXZStream(rewindableStream)) { rewindableStream.Rewind(true); - XZStream testStream = new XZStream(rewindableStream); - if (TarArchive.IsTarFile(testStream)) - { - rewindableStream.Rewind(true); - return new TarReader(rewindableStream, options, CompressionType.Xz); - } + /* XZStream testStream = new XZStream(rewindableStream); + if (TarArchive.IsTarFile(testStream)) + { + rewindableStream.Rewind(true); + return new TarReader(rewindableStream, options, CompressionType.Xz); + } */ } throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ"); } diff --git a/src/SharpCompress/Writers/AbstractWriter.cs b/src/SharpCompress/Writers/AbstractWriter.cs index bc4087bd..94f58681 100644 --- a/src/SharpCompress/Writers/AbstractWriter.cs +++ b/src/SharpCompress/Writers/AbstractWriter.cs @@ -27,7 +27,7 @@ namespace SharpCompress.Writers protected WriterOptions WriterOptions { get; } - public abstract Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken); + public abstract ValueTask WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken); public async ValueTask DisposeAsync() { diff --git a/src/SharpCompress/Writers/GZip/GZipWriter.cs b/src/SharpCompress/Writers/GZip/GZipWriter.cs index bdfc54ce..9381396f 100644 --- a/src/SharpCompress/Writers/GZip/GZipWriter.cs +++ b/src/SharpCompress/Writers/GZip/GZipWriter.cs @@ -31,7 +31,7 @@ namespace SharpCompress.Writers.GZip return OutputStream.DisposeAsync(); } - public override async Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken) + public override async ValueTask WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken) { if (_wroteToStream) { @@ -40,7 +40,7 @@ namespace SharpCompress.Writers.GZip GZipStream stream = (GZipStream)OutputStream; stream.FileName = filename; stream.LastModified = modificationTime; - await source.TransferToAsync(stream); + await source.TransferToAsync(stream, cancellationToken); _wroteToStream = true; } } diff --git a/src/SharpCompress/Writers/IWriter.cs b/src/SharpCompress/Writers/IWriter.cs index fbfb4f92..42a8b439 100644 --- a/src/SharpCompress/Writers/IWriter.cs +++ b/src/SharpCompress/Writers/IWriter.cs @@ -9,6 +9,6 @@ namespace SharpCompress.Writers public interface IWriter : IAsyncDisposable { ArchiveType WriterType { get; } - Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken = default); + ValueTask WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken = default); } } \ No newline at end of file diff --git a/src/SharpCompress/Writers/IWriterExtensions.cs b/src/SharpCompress/Writers/IWriterExtensions.cs index b2022df9..0f21c29e 100644 --- a/src/SharpCompress/Writers/IWriterExtensions.cs +++ b/src/SharpCompress/Writers/IWriterExtensions.cs @@ -9,12 +9,12 @@ namespace SharpCompress.Writers { public static class IWriterExtensions { - public static Task WriteAsync(this IWriter writer, string entryPath, Stream source, CancellationToken cancellationToken = default) + public static ValueTask WriteAsync(this IWriter writer, string entryPath, Stream source, CancellationToken cancellationToken = default) { return writer.WriteAsync(entryPath, source, null, cancellationToken); } - public static async Task WriteAsync(this IWriter writer, string entryPath, FileInfo source, CancellationToken cancellationToken = default) + public static async ValueTask WriteAsync(this IWriter writer, string entryPath, FileInfo source, CancellationToken cancellationToken = default) { if (!source.Exists) { @@ -26,21 +26,21 @@ namespace SharpCompress.Writers } } - public static Task WriteAsync(this IWriter writer, string entryPath, string source, CancellationToken cancellationToken = default) + public static ValueTask WriteAsync(this IWriter writer, string entryPath, string source, CancellationToken cancellationToken = default) { return writer.WriteAsync(entryPath, new FileInfo(source), cancellationToken); } - public static Task WriteAllAsync(this IWriter writer, string directory, string searchPattern = "*", SearchOption option = SearchOption.TopDirectoryOnly, CancellationToken cancellationToken = default) + public static ValueTask WriteAllAsync(this IWriter writer, string directory, string searchPattern = "*", SearchOption option = SearchOption.TopDirectoryOnly, CancellationToken cancellationToken = default) { return writer.WriteAllAsync(directory, searchPattern, null, option, cancellationToken); } - public static async Task WriteAllAsync(this IWriter writer, - string directory, - string searchPattern = "*", - Expression>? fileSearchFunc = null, - SearchOption option = SearchOption.TopDirectoryOnly, CancellationToken cancellationToken = default) + public static async ValueTask WriteAllAsync(this IWriter writer, + string directory, + string searchPattern = "*", + Expression>? fileSearchFunc = null, + SearchOption option = SearchOption.TopDirectoryOnly, CancellationToken cancellationToken = default) { if (!Directory.Exists(directory)) { diff --git a/src/SharpCompress/Writers/WriterFactory.cs b/src/SharpCompress/Writers/WriterFactory.cs index fcb0fd41..e32e3ec7 100644 --- a/src/SharpCompress/Writers/WriterFactory.cs +++ b/src/SharpCompress/Writers/WriterFactory.cs @@ -2,7 +2,7 @@ using System.IO; using SharpCompress.Common; using SharpCompress.Writers.GZip; -using SharpCompress.Writers.Tar; +//using SharpCompress.Writers.Tar; using SharpCompress.Writers.Zip; namespace SharpCompress.Writers @@ -26,9 +26,10 @@ namespace SharpCompress.Writers return new ZipWriter(stream, new ZipWriterOptions(writerOptions)); } case ArchiveType.Tar: - { - return new TarWriter(stream, new TarWriterOptions(writerOptions)); - } + { + throw new NotImplementedException(); + //return new TarWriter(stream, new TarWriterOptions(writerOptions)); + } default: { throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType); diff --git a/src/SharpCompress/Writers/Zip/ZipWriter.cs b/src/SharpCompress/Writers/Zip/ZipWriter.cs index 8fde488f..2712c260 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriter.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs @@ -96,21 +96,21 @@ namespace SharpCompress.Writers.Zip } } - public override Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken) + public override ValueTask WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken = default) { return WriteAsync(filename, source, new ZipWriterEntryOptions() { ModificationDateTime = modificationTime - }); + }, cancellationToken); } - public async Task WriteAsync(string entryPath, Stream source, ZipWriterEntryOptions zipWriterEntryOptions) + public async ValueTask WriteAsync(string entryPath, Stream source, ZipWriterEntryOptions zipWriterEntryOptions, CancellationToken cancellationToken = default) { - await using Stream output = await WriteToStreamAsync(entryPath, zipWriterEntryOptions); - await source.TransferToAsync(output); + await using Stream output = await WriteToStreamAsync(entryPath, zipWriterEntryOptions, cancellationToken); + await source.TransferToAsync(output, cancellationToken); } - public async Task WriteToStreamAsync(string entryPath, ZipWriterEntryOptions options) + public async ValueTask WriteToStreamAsync(string entryPath, ZipWriterEntryOptions options, CancellationToken cancellationToken = default) { var compression = ToZipCompressionMethod(options.CompressionType ?? compressionType); @@ -130,7 +130,7 @@ namespace SharpCompress.Writers.Zip useZip64 = options.EnableZip64.Value; } - var headersize = (uint)(await WriteHeaderAsync(entryPath, options, entry, useZip64)); + var headersize = (uint)(await WriteHeaderAsync(entryPath, options, entry, useZip64, cancellationToken)); streamPosition += headersize; return new ZipWritingStream(this, OutputStream, entry, compression, options.DeflateCompressionLevel ?? compressionLevel); @@ -149,7 +149,8 @@ namespace SharpCompress.Writers.Zip return filename.Trim('/'); } - private async Task WriteHeaderAsync(string filename, ZipWriterEntryOptions zipWriterEntryOptions, ZipCentralDirectoryEntry entry, bool useZip64) + private async Task WriteHeaderAsync(string filename, ZipWriterEntryOptions zipWriterEntryOptions, ZipCentralDirectoryEntry entry, bool useZip64, + CancellationToken cancellationToken) { // We err on the side of caution until the zip specification clarifies how to support this if (!OutputStream.CanSeek && useZip64) @@ -163,7 +164,7 @@ namespace SharpCompress.Writers.Zip // TODO: Use stackalloc when we exclusively support netstandard2.1 or higher using var intBuf = MemoryPool.Shared.Rent(4); BinaryPrimitives.WriteUInt32LittleEndian(intBuf.Memory.Span, ZipHeaderFactory.ENTRY_HEADER_BYTES); - await OutputStream.WriteAsync(intBuf.Memory); + await OutputStream.WriteAsync(intBuf.Memory, cancellationToken); if (explicitZipCompressionInfo == ZipCompressionMethod.Deflate) { if (OutputStream.CanSeek && useZip64) @@ -171,14 +172,14 @@ namespace SharpCompress.Writers.Zip using var buf1 = MemoryPool.Shared.Rent(2); buf1.Memory.Span[0] = 45; buf1.Memory.Span[1] = 0; - await OutputStream.WriteAsync(buf1.Memory); //smallest allowed version for zip64 + await OutputStream.WriteAsync(buf1.Memory, cancellationToken); //smallest allowed version for zip64 } else { using var buf1 = MemoryPool.Shared.Rent(2); buf1.Memory.Span[0] = 20; buf1.Memory.Span[1] = 0; - await OutputStream.WriteAsync(buf1.Memory); //older version which is more compatible + await OutputStream.WriteAsync(buf1.Memory, cancellationToken); //older version which is more compatible } } else @@ -186,7 +187,7 @@ namespace SharpCompress.Writers.Zip using var buf1 = MemoryPool.Shared.Rent(2); buf1.Memory.Span[0] = 63; buf1.Memory.Span[1] = 0; - await OutputStream.WriteAsync(buf1.Memory); //version says we used PPMd or LZMA + await OutputStream.WriteAsync(buf1.Memory, cancellationToken); //version says we used PPMd or LZMA } HeaderFlags flags = Equals(WriterOptions.ArchiveEncoding.GetEncoding(), Encoding.UTF8) ? HeaderFlags.Efs : 0; if (!OutputStream.CanSeek) @@ -200,20 +201,20 @@ namespace SharpCompress.Writers.Zip } BinaryPrimitives.WriteUInt16LittleEndian(intBuf.Memory.Span, (ushort)flags); - await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2)); + await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2), cancellationToken); BinaryPrimitives.WriteUInt16LittleEndian(intBuf.Memory.Span, (ushort)explicitZipCompressionInfo); - await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2)); // zipping method + await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2), cancellationToken); // zipping method BinaryPrimitives.WriteUInt32LittleEndian(intBuf.Memory.Span, zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime()); - await OutputStream.WriteAsync(intBuf.Memory); + await OutputStream.WriteAsync(intBuf.Memory, cancellationToken); // zipping date and time using var buf2 = MemoryPool.Shared.Rent(12); buf2.Memory.Span.Clear(); - await OutputStream.WriteAsync(buf2.Memory); + await OutputStream.WriteAsync(buf2.Memory, cancellationToken); // unused CRC, un/compressed size, updated later BinaryPrimitives.WriteUInt16LittleEndian(intBuf.Memory.Span, (ushort)encodedFilename.Length); - await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2));// filename length + await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2), cancellationToken);// filename length var extralength = 0; if (OutputStream.CanSeek && useZip64) @@ -222,14 +223,14 @@ namespace SharpCompress.Writers.Zip } BinaryPrimitives.WriteUInt16LittleEndian(intBuf.Memory.Span, (ushort)extralength); - await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2));// extra length - await OutputStream.WriteAsync(encodedFilename, 0, encodedFilename.Length); + await OutputStream.WriteAsync(intBuf.Memory.Slice(0,2), cancellationToken);// extra length + await OutputStream.WriteAsync(encodedFilename, 0, encodedFilename.Length, cancellationToken); if (extralength != 0) { using var buf3 = MemoryPool.Shared.Rent(extralength); buf2.Memory.Span.Clear(); - await OutputStream.WriteAsync(buf3.Memory); // reserve space for zip64 data + await OutputStream.WriteAsync(buf3.Memory, cancellationToken); // reserve space for zip64 data entry.Zip64HeaderOffset = (ushort)(6 + 2 + 2 + 4 + 12 + 2 + 2 + encodedFilename.Length); } diff --git a/tests/SharpCompress.Test/ArchiveTests.cs b/tests/SharpCompress.Test/ArchiveTests.cs index cfa247e5..9ba5a7db 100644 --- a/tests/SharpCompress.Test/ArchiveTests.cs +++ b/tests/SharpCompress.Test/ArchiveTests.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Threading.Tasks; using SharpCompress.Archives; using SharpCompress.Common; using SharpCompress.IO; @@ -12,24 +13,24 @@ namespace SharpCompress.Test { public class ArchiveTests : ReaderTests { - protected void ArchiveStreamReadExtractAll(string testArchive, CompressionType compression) + protected async ValueTask ArchiveStreamReadExtractAll(string testArchive, CompressionType compression) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - ArchiveStreamReadExtractAll(testArchive.AsEnumerable(), compression); + await ArchiveStreamReadExtractAll(testArchive.AsEnumerable(), compression); } - protected void ArchiveStreamReadExtractAll(IEnumerable testArchives, CompressionType compression) + protected async ValueTask ArchiveStreamReadExtractAll(IEnumerable testArchives, CompressionType compression) { foreach (var path in testArchives) { - using (var stream = new NonDisposingStream(File.OpenRead(path), true)) - using (var archive = ArchiveFactory.Open(stream)) + await using (var stream = new NonDisposingStream(File.OpenRead(path), true)) + using (var archive = await ArchiveFactory.OpenAsync(stream)) { Assert.True(archive.IsSolid); - using (var reader = archive.ExtractAllEntries()) + await using (var reader = archive.ExtractAllEntries()) { - UseReader(reader, compression); + await ReadAsync(reader, compression); } VerifyFiles(); @@ -40,7 +41,7 @@ namespace SharpCompress.Test } foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions { ExtractFullPath = true, @@ -53,29 +54,29 @@ namespace SharpCompress.Test } } - protected void ArchiveStreamRead(string testArchive, ReaderOptions readerOptions = null) + protected ValueTask ArchiveStreamReadAsync(string testArchive, ReaderOptions readerOptions = null) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - ArchiveStreamRead(readerOptions, testArchive.AsEnumerable()); + return ArchiveStreamReadAsync(readerOptions, testArchive.AsEnumerable()); } - protected void ArchiveStreamRead(ReaderOptions readerOptions = null, params string[] testArchives) + protected ValueTask ArchiveStreamReadAsync(ReaderOptions readerOptions = null, params string[] testArchives) { - ArchiveStreamRead(readerOptions, testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x))); + return ArchiveStreamReadAsync(readerOptions, testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x))); } - protected void ArchiveStreamRead(ReaderOptions readerOptions, IEnumerable testArchives) + protected async ValueTask ArchiveStreamReadAsync(ReaderOptions readerOptions, IEnumerable testArchives) { foreach (var path in testArchives) { using (var stream = new NonDisposingStream(File.OpenRead(path), true)) - using (var archive = ArchiveFactory.Open(stream, readerOptions)) + using (var archive = await ArchiveFactory.OpenAsync(stream, readerOptions)) { try { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -95,14 +96,14 @@ namespace SharpCompress.Test } } - protected void ArchiveFileRead(string testArchive, ReaderOptions readerOptions = null) + protected async ValueTask ArchiveFileReadAsync(string testArchive, ReaderOptions readerOptions = null) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using (var archive = ArchiveFactory.Open(testArchive, readerOptions)) + using (var archive = await ArchiveFactory.OpenAsync(testArchive, readerOptions)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -116,14 +117,14 @@ namespace SharpCompress.Test /// /// Demonstrate the ExtractionOptions.PreserveFileTime and ExtractionOptions.PreserveAttributes extract options /// - protected void ArchiveFileReadEx(string testArchive) + protected async ValueTask ArchiveFileReadEx(string testArchive) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using (var archive = ArchiveFactory.Open(testArchive)) + using (var archive = await ArchiveFactory.OpenAsync(testArchive)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, diff --git a/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs b/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs index b83ded23..a9c2e21a 100644 --- a/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs @@ -16,13 +16,13 @@ namespace SharpCompress.Test.GZip } [Fact] - public void GZip_Archive_Generic() + public async ValueTask GZip_Archive_Generic() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) - using (var archive = ArchiveFactory.Open(stream)) + using (var archive = await ArchiveFactory.OpenAsync(stream)) { var entry = archive.Entries.First(); - entry.WriteToFile(Path.Combine(SCRATCH_FILES_PATH, entry.Key)); + await entry.WriteToFileAsync(Path.Combine(SCRATCH_FILES_PATH, entry.Key)); long size = entry.Size; var scratch = new FileInfo(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar")); @@ -31,18 +31,18 @@ namespace SharpCompress.Test.GZip Assert.Equal(size, scratch.Length); Assert.Equal(size, test.Length); } - CompareArchivesByPath(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar"), - Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); + await CompareArchivesByPathAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar"), + Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); } [Fact] - public void GZip_Archive() + public async ValueTask GZip_Archive() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) using (var archive = GZipArchive.Open(stream)) { var entry = archive.Entries.First(); - entry.WriteToFile(Path.Combine(SCRATCH_FILES_PATH, entry.Key)); + await entry.WriteToFileAsync(Path.Combine(SCRATCH_FILES_PATH, entry.Key)); long size = entry.Size; var scratch = new FileInfo(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar")); @@ -51,8 +51,8 @@ namespace SharpCompress.Test.GZip Assert.Equal(size, scratch.Length); Assert.Equal(size, test.Length); } - CompareArchivesByPath(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar"), - Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); + await CompareArchivesByPathAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar"), + Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); } @@ -95,11 +95,11 @@ namespace SharpCompress.Test.GZip entryStream.CopyTo(tarStream); } Assert.Equal(size, tarStream.Length); - using (var entryStream = archiveEntry.OpenEntryStream()) + /*using (var entryStream = archiveEntry.OpenEntryStream()) { var result = Archives.Tar.TarArchive.IsTarFile(entryStream); } - Assert.Equal(size, tarStream.Length); + Assert.Equal(size, tarStream.Length); */ using (var entryStream = archiveEntry.OpenEntryStream()) { tarStream = new MemoryStream(); diff --git a/tests/SharpCompress.Test/GZip/GZipReaderTests.cs b/tests/SharpCompress.Test/GZip/GZipReaderTests.cs index bab72e97..701865be 100644 --- a/tests/SharpCompress.Test/GZip/GZipReaderTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipReaderTests.cs @@ -1,4 +1,5 @@ using System.IO; +using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.IO; using Xunit; @@ -13,20 +14,20 @@ namespace SharpCompress.Test.GZip } [Fact] - public void GZip_Reader_Generic() + public async ValueTask GZip_Reader_Generic() { - Read("Tar.tar.gz", CompressionType.GZip); + await ReadAsync("Tar.tar.gz", CompressionType.GZip); } [Fact] - public void GZip_Reader_Generic2() + public async ValueTask GZip_Reader_Generic2() { //read only as GZip itme using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) - using (var reader = SharpCompress.Readers.GZip.GZipReader.Open(new RewindableStream(stream))) + await using (var reader = SharpCompress.Readers.GZip.GZipReader.Open(new RewindableStream(stream))) { - while (reader.MoveToNextEntry()) // Crash here + while (await reader.MoveToNextEntry()) // Crash here { Assert.NotEqual(0, reader.Entry.Size); Assert.NotEqual(0, reader.Entry.Crc); diff --git a/tests/SharpCompress.Test/GZip/GZipWriterTests.cs b/tests/SharpCompress.Test/GZip/GZipWriterTests.cs index cf1f1f2d..44cd9e7e 100644 --- a/tests/SharpCompress.Test/GZip/GZipWriterTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipWriterTests.cs @@ -18,25 +18,25 @@ namespace SharpCompress.Test.GZip [Fact] public async Task GZip_Writer_Generic() { - using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write)) + await using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write)) await using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.GZip)) { await writer.WriteAsync("Tar.tar", Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); } - CompareArchivesByPath(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), - Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); + await CompareArchivesByPathAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), + Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); } [Fact] public async Task GZip_Writer() { - using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write)) + await using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write)) await using (var writer = new GZipWriter(stream)) { await writer.WriteAsync("Tar.tar", Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); } - CompareArchivesByPath(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), - Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); + await CompareArchivesByPathAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), + Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); } [Fact] @@ -44,7 +44,7 @@ namespace SharpCompress.Test.GZip { await Assert.ThrowsAsync(async () => { - using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"))) + await using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"))) await using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.BZip2)) { } @@ -54,14 +54,14 @@ namespace SharpCompress.Test.GZip [Fact] public async Task GZip_Writer_Entry_Path_With_Dir() { - using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write)) + await using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write)) await using (var writer = new GZipWriter(stream)) { var path = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"); await writer.WriteAsync(path, path); //covers issue #532 } - CompareArchivesByPath(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), - Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); + await CompareArchivesByPathAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), + Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); } } } diff --git a/tests/SharpCompress.Test/ReaderTests.cs b/tests/SharpCompress.Test/ReaderTests.cs index 82ca6d29..671d60d8 100644 --- a/tests/SharpCompress.Test/ReaderTests.cs +++ b/tests/SharpCompress.Test/ReaderTests.cs @@ -1,4 +1,5 @@ using System.IO; +using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.IO; using SharpCompress.Readers; @@ -9,21 +10,21 @@ namespace SharpCompress.Test { public abstract class ReaderTests : TestBase { - protected void Read(string testArchive, CompressionType expectedCompression, ReaderOptions options = null) + protected async ValueTask ReadAsync(string testArchive, CompressionType expectedCompression, ReaderOptions options = null) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - options = options ?? new ReaderOptions(); + options ??= new ReaderOptions(); options.LeaveStreamOpen = true; - ReadImpl(testArchive, expectedCompression, options); + await ReadImplAsync(testArchive, expectedCompression, options); options.LeaveStreamOpen = false; - ReadImpl(testArchive, expectedCompression, options); + await ReadImplAsync(testArchive, expectedCompression, options); VerifyFiles(); } - private void ReadImpl(string testArchive, CompressionType expectedCompression, ReaderOptions options) + private async ValueTask ReadImplAsync(string testArchive, CompressionType expectedCompression, ReaderOptions options) { using (var file = File.OpenRead(testArchive)) { @@ -31,9 +32,9 @@ namespace SharpCompress.Test { using (var testStream = new TestStream(protectedStream)) { - using (var reader = ReaderFactory.Open(testStream, options)) + await using (var reader = await ReaderFactory.OpenAsync(testStream, options)) { - UseReader(reader, expectedCompression); + await ReadAsync(reader, expectedCompression); protectedStream.ThrowOnDispose = false; Assert.False(testStream.IsDisposed, "{nameof(testStream)} prematurely closed"); } @@ -47,14 +48,14 @@ namespace SharpCompress.Test } } - public void UseReader(IReader reader, CompressionType expectedCompression) + public async ValueTask ReadAsync(IReader reader, CompressionType expectedCompression) { - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { Assert.Equal(expectedCompression, reader.Entry.CompressionType); - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, Overwrite = true diff --git a/tests/SharpCompress.Test/TestBase.cs b/tests/SharpCompress.Test/TestBase.cs index 0c1db9d0..a7cf6494 100644 --- a/tests/SharpCompress.Test/TestBase.cs +++ b/tests/SharpCompress.Test/TestBase.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; +using System.Threading.Tasks; using SharpCompress.Readers; using Xunit; @@ -188,7 +189,7 @@ namespace SharpCompress.Test Assert.Equal(fi1.Attributes, fi2.Attributes); } - protected void CompareArchivesByPath(string file1, string file2, Encoding encoding = null) + protected async ValueTask CompareArchivesByPathAsync(string file1, string file2, Encoding encoding = null) { ReaderOptions readerOptions = new ReaderOptions { LeaveStreamOpen = false }; readerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; @@ -196,16 +197,16 @@ namespace SharpCompress.Test //don't compare the order. OS X reads files from the file system in a different order therefore makes the archive ordering different var archive1Entries = new List(); var archive2Entries = new List(); - using (var archive1 = ReaderFactory.Open(File.OpenRead(file1), readerOptions)) - using (var archive2 = ReaderFactory.Open(File.OpenRead(file2), readerOptions)) + await using (var archive1 = await ReaderFactory.OpenAsync(File.OpenRead(file1), readerOptions)) + await using (var archive2 = await ReaderFactory.OpenAsync(File.OpenRead(file2), readerOptions)) { - while (archive1.MoveToNextEntry()) + while (await archive1.MoveToNextEntry()) { - Assert.True(archive2.MoveToNextEntry()); + Assert.True(await archive2.MoveToNextEntry()); archive1Entries.Add(archive1.Entry.Key); archive2Entries.Add(archive2.Entry.Key); } - Assert.False(archive2.MoveToNextEntry()); + Assert.False(await archive2.MoveToNextEntry()); } archive1Entries.Sort(); archive2Entries.Sort(); diff --git a/tests/SharpCompress.Test/WriterTests.cs b/tests/SharpCompress.Test/WriterTests.cs index cda40f83..a375c19c 100644 --- a/tests/SharpCompress.Test/WriterTests.cs +++ b/tests/SharpCompress.Test/WriterTests.cs @@ -33,8 +33,8 @@ namespace SharpCompress.Test await writer.WriteAllAsync(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories); } } - CompareArchivesByPath(Path.Combine(SCRATCH2_FILES_PATH, archive), - Path.Combine(TEST_ARCHIVES_PATH, archiveToVerifyAgainst)); + await CompareArchivesByPathAsync(Path.Combine(SCRATCH2_FILES_PATH, archive), + Path.Combine(TEST_ARCHIVES_PATH, archiveToVerifyAgainst)); using (Stream stream = File.OpenRead(Path.Combine(SCRATCH2_FILES_PATH, archive))) { @@ -42,9 +42,9 @@ namespace SharpCompress.Test readerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; - using (var reader = ReaderFactory.Open(new NonDisposingStream(stream), readerOptions)) + await using (var reader = await ReaderFactory.OpenAsync(new NonDisposingStream(stream), readerOptions)) { - reader.WriteAllToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true }); diff --git a/tests/SharpCompress.Test/Zip/Zip64Tests.cs b/tests/SharpCompress.Test/Zip/Zip64Tests.cs index 0bc43fe7..14cb205c 100644 --- a/tests/SharpCompress.Test/Zip/Zip64Tests.cs +++ b/tests/SharpCompress.Test/Zip/Zip64Tests.cs @@ -100,7 +100,7 @@ namespace SharpCompress.Test.Zip } } - public async Task RunSingleTest(long files, long filesize, bool set_zip64, bool forward_only, long write_chunk_size = 1024 * 1024, string filename = "zip64-test.zip") + public async ValueTask RunSingleTest(long files, long filesize, bool set_zip64, bool forward_only, long write_chunk_size = 1024 * 1024, string filename = "zip64-test.zip") { filename = Path.Combine(SCRATCH2_FILES_PATH, filename); @@ -114,7 +114,7 @@ namespace SharpCompress.Test.Zip await CreateZipArchive(filename, files, filesize, write_chunk_size, set_zip64, forward_only); } - var resForward = ReadForwardOnly(filename); + var resForward = await ReadForwardOnly(filename); if (resForward.Item1 != files) { throw new Exception($"Incorrect number of items reported: {resForward.Item1}, should have been {files}"); @@ -125,7 +125,7 @@ namespace SharpCompress.Test.Zip throw new Exception($"Incorrect combined size reported: {resForward.Item2}, should have been {files * filesize}"); } - var resArchive = ReadArchive(filename); + var resArchive = await ReadArchive(filename); if (resArchive.Item1 != files) { throw new Exception($"Incorrect number of items reported: {resArchive.Item1}, should have been {files}"); @@ -168,15 +168,15 @@ namespace SharpCompress.Test.Zip } } - public Tuple ReadForwardOnly(string filename) + public async ValueTask<(long, long)> ReadForwardOnly(string filename) { long count = 0; long size = 0; Common.Zip.ZipEntry prev = null; using (var fs = File.OpenRead(filename)) - using (var rd = ZipReader.Open(fs, new ReaderOptions() { LookForHeader = false })) + await using (var rd = ZipReader.Open(fs, new ReaderOptions() { LookForHeader = false })) { - while (rd.MoveToNextEntry()) + while (await rd.MoveToNextEntry()) { using (rd.OpenEntryStream()) { } @@ -196,14 +196,14 @@ namespace SharpCompress.Test.Zip size += prev.Size; } - return new Tuple(count, size); + return (count, size); } - public Tuple ReadArchive(string filename) + public async ValueTask<(long, long)> ReadArchive(string filename) { - using (var archive = ArchiveFactory.Open(filename)) + using (var archive = await ArchiveFactory.OpenAsync(filename)) { - return new Tuple( + return ( archive.Entries.Count(), archive.Entries.Select(x => x.Size).Sum() ); diff --git a/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs b/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs index 19ba8b98..0c06b3b5 100644 --- a/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs @@ -21,139 +21,139 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_ZipX_ArchiveStreamRead() + public async ValueTask Zip_ZipX_ArchiveStreamRead() { - ArchiveStreamRead("Zip.zipx"); + await ArchiveStreamReadAsync("Zip.zipx"); } [Fact] - public void Zip_BZip2_Streamed_ArchiveStreamRead() + public async ValueTask Zip_BZip2_Streamed_ArchiveStreamRead() { - ArchiveStreamRead("Zip.bzip2.dd.zip"); + await ArchiveStreamReadAsync("Zip.bzip2.dd.zip"); } [Fact] - public void Zip_BZip2_ArchiveStreamRead() + public async ValueTask Zip_BZip2_ArchiveStreamRead() { - ArchiveStreamRead("Zip.bzip2.zip"); + await ArchiveStreamReadAsync("Zip.bzip2.zip"); } [Fact] - public void Zip_Deflate_Streamed2_ArchiveStreamRead() + public async ValueTask Zip_Deflate_Streamed2_ArchiveStreamRead() { - ArchiveStreamRead("Zip.deflate.dd-.zip"); + await ArchiveStreamReadAsync("Zip.deflate.dd-.zip"); } [Fact] - public void Zip_Deflate_Streamed_ArchiveStreamRead() + public async ValueTask Zip_Deflate_Streamed_ArchiveStreamRead() { - ArchiveStreamRead("Zip.deflate.dd.zip"); + await ArchiveStreamReadAsync("Zip.deflate.dd.zip"); } [Fact] - public void Zip_Deflate_ArchiveStreamRead() + public async ValueTask Zip_Deflate_ArchiveStreamRead() { - ArchiveStreamRead("Zip.deflate.zip"); + await ArchiveStreamReadAsync("Zip.deflate.zip"); } [Fact] - public void Zip_Deflate64_ArchiveStreamRead() + public async ValueTask Zip_Deflate64_ArchiveStreamRead() { - ArchiveStreamRead("Zip.deflate64.zip"); + await ArchiveStreamReadAsync("Zip.deflate64.zip"); } [Fact] - public void Zip_LZMA_Streamed_ArchiveStreamRead() + public async ValueTask Zip_LZMA_Streamed_ArchiveStreamRead() { - ArchiveStreamRead("Zip.lzma.dd.zip"); + await ArchiveStreamReadAsync("Zip.lzma.dd.zip"); } [Fact] - public void Zip_LZMA_ArchiveStreamRead() + public async ValueTask Zip_LZMA_ArchiveStreamRead() { - ArchiveStreamRead("Zip.lzma.zip"); + await ArchiveStreamReadAsync("Zip.lzma.zip"); } [Fact] - public void Zip_PPMd_Streamed_ArchiveStreamRead() + public async ValueTask Zip_PPMd_Streamed_ArchiveStreamRead() { - ArchiveStreamRead("Zip.ppmd.dd.zip"); + await ArchiveStreamReadAsync("Zip.ppmd.dd.zip"); } [Fact] - public void Zip_PPMd_ArchiveStreamRead() + public async ValueTask Zip_PPMd_ArchiveStreamRead() { - ArchiveStreamRead("Zip.ppmd.zip"); + await ArchiveStreamReadAsync("Zip.ppmd.zip"); } [Fact] - public void Zip_None_ArchiveStreamRead() + public async ValueTask Zip_None_ArchiveStreamRead() { - ArchiveStreamRead("Zip.none.zip"); + await ArchiveStreamReadAsync("Zip.none.zip"); } [Fact] - public void Zip_BZip2_Streamed_ArchiveFileRead() + public async ValueTask Zip_BZip2_Streamed_ArchiveFileRead() { - ArchiveFileRead("Zip.bzip2.dd.zip"); + await ArchiveStreamReadAsync("Zip.bzip2.dd.zip"); } [Fact] - public void Zip_BZip2_ArchiveFileRead() + public async ValueTask Zip_BZip2_ArchiveFileRead() { - ArchiveFileRead("Zip.bzip2.zip"); + await ArchiveStreamReadAsync("Zip.bzip2.zip"); } [Fact] - public void Zip_Deflate_Streamed2_ArchiveFileRead() + public async ValueTask Zip_Deflate_Streamed2_ArchiveFileRead() { - ArchiveFileRead("Zip.deflate.dd-.zip"); + await ArchiveStreamReadAsync("Zip.deflate.dd-.zip"); } [Fact] - public void Zip_Deflate_Streamed_ArchiveFileRead() + public async ValueTask Zip_Deflate_Streamed_ArchiveFileRead() { - ArchiveFileRead("Zip.deflate.dd.zip"); + await ArchiveStreamReadAsync("Zip.deflate.dd.zip"); } [Fact] - public void Zip_Deflate_ArchiveFileRead() + public async ValueTask Zip_Deflate_ArchiveFileRead() { - ArchiveFileRead("Zip.deflate.zip"); + await ArchiveStreamReadAsync("Zip.deflate.zip"); } [Fact] - public void Zip_Deflate64_ArchiveFileRead() + public async ValueTask Zip_Deflate64_ArchiveFileRead() { - ArchiveFileRead("Zip.deflate64.zip"); + await ArchiveStreamReadAsync("Zip.deflate64.zip"); } [Fact] - public void Zip_LZMA_Streamed_ArchiveFileRead() + public async ValueTask Zip_LZMA_Streamed_ArchiveFileRead() { - ArchiveFileRead("Zip.lzma.dd.zip"); + await ArchiveStreamReadAsync("Zip.lzma.dd.zip"); } [Fact] - public void Zip_LZMA_ArchiveFileRead() + public async ValueTask Zip_LZMA_ArchiveFileRead() { - ArchiveFileRead("Zip.lzma.zip"); + await ArchiveStreamReadAsync("Zip.lzma.zip"); } [Fact] - public void Zip_PPMd_Streamed_ArchiveFileRead() + public async ValueTask Zip_PPMd_Streamed_ArchiveFileRead() { - ArchiveFileRead("Zip.ppmd.dd.zip"); + await ArchiveStreamReadAsync("Zip.ppmd.dd.zip"); } [Fact] - public void Zip_PPMd_ArchiveFileRead() + public async ValueTask Zip_PPMd_ArchiveFileRead() { - ArchiveFileRead("Zip.ppmd.zip"); + await ArchiveStreamReadAsync("Zip.ppmd.zip"); } [Fact] - public void Zip_None_ArchiveFileRead() + public async ValueTask Zip_None_ArchiveFileRead() { - ArchiveFileRead("Zip.none.zip"); + await ArchiveStreamReadAsync("Zip.none.zip"); } [Fact] - public void Zip_Zip64_ArchiveStreamRead() + public async ValueTask Zip_Zip64_ArchiveStreamRead() { - ArchiveStreamRead("Zip.zip64.zip"); + await ArchiveStreamReadAsync("Zip.zip64.zip"); } [Fact] - public void Zip_Zip64_ArchiveFileRead() + public async ValueTask Zip_Zip64_ArchiveFileRead() { - ArchiveFileRead("Zip.zip64.zip"); + await ArchiveStreamReadAsync("Zip.zip64.zip"); } [Fact] - public async Task Zip_Random_Write_Remove() + public async ValueTask Zip_Random_Write_Remove() { string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Zip.deflate.mod.zip"); string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); @@ -169,7 +169,7 @@ namespace SharpCompress.Test.Zip await archive.SaveToAsync(scratchPath, writerOptions); } - CompareArchivesByPath(modified, scratchPath, Encoding.GetEncoding(866)); + await CompareArchivesByPathAsync(modified, scratchPath, Encoding.GetEncoding(866)); } [Fact] @@ -189,7 +189,7 @@ namespace SharpCompress.Test.Zip await archive.SaveToAsync(scratchPath, writerOptions); } - CompareArchivesByPath(modified, scratchPath, Encoding.GetEncoding(866)); + await CompareArchivesByPathAsync(modified, scratchPath, Encoding.GetEncoding(866)); } [Fact] @@ -211,20 +211,16 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Removal_Poly() + public async ValueTask Zip_Removal_Poly() { string scratchPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - - - using (ZipArchive vfs = (ZipArchive)ArchiveFactory.Open(scratchPath)) - { - var e = vfs.Entries.First(v => v.Key.EndsWith("jpg")); - vfs.RemoveEntry(e); - Assert.Null(vfs.Entries.FirstOrDefault(v => v.Key.EndsWith("jpg"))); - Assert.Null(((IArchive)vfs).Entries.FirstOrDefault(v => v.Key.EndsWith("jpg"))); - } + using ZipArchive vfs = (ZipArchive)await ArchiveFactory.OpenAsync(scratchPath); + var e = vfs.Entries.First(v => v.Key.EndsWith("jpg")); + vfs.RemoveEntry(e); + Assert.Null(vfs.Entries.FirstOrDefault(v => v.Key.EndsWith("jpg"))); + Assert.Null(((IArchive)vfs).Entries.FirstOrDefault(v => v.Key.EndsWith("jpg"))); } [Fact] @@ -287,7 +283,7 @@ namespace SharpCompress.Test.Zip await archive.SaveToAsync(scratchPath, writerOptions); } - CompareArchivesByPath(unmodified, scratchPath, Encoding.GetEncoding(866)); + await CompareArchivesByPathAsync(unmodified, scratchPath, Encoding.GetEncoding(866)); Directory.Delete(SCRATCH_FILES_PATH, true); } @@ -321,7 +317,7 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Deflate_WinzipAES_Read() + public async ValueTask Zip_Deflate_WinzipAES_Read() { using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"), new ReaderOptions() { @@ -330,7 +326,7 @@ namespace SharpCompress.Test.Zip { foreach (var entry in reader.Entries.Where(x => !x.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, Overwrite = true @@ -375,7 +371,7 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_BZip2_Pkware_Read() + public async ValueTask Zip_BZip2_Pkware_Read() { using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip"), new ReaderOptions() { @@ -384,7 +380,7 @@ namespace SharpCompress.Test.Zip { foreach (var entry in reader.Entries.Where(x => !x.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, Overwrite = true @@ -438,45 +434,41 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Deflate_PKWear_Multipy_Entry_Access() + public async ValueTask Zip_Deflate_PKWear_Multipy_Entry_Access() { string zipFile = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.pkware.zip"); - using (FileStream fileStream = File.Open(zipFile, FileMode.Open)) + await using FileStream fileStream = File.Open(zipFile, FileMode.Open); + using IArchive archive = await ArchiveFactory.OpenAsync(fileStream, new ReaderOptions { Password = "12345678" }); + var entries = archive.Entries.Where(entry => !entry.IsDirectory); + foreach (IArchiveEntry entry in entries) { - using (IArchive archive = ArchiveFactory.Open(fileStream, new ReaderOptions { Password = "12345678" })) + for (var i = 0; i < 100; i++) { - var entries = archive.Entries.Where(entry => !entry.IsDirectory); - foreach (IArchiveEntry entry in entries) + await using (var memoryStream = new MemoryStream()) + await using (Stream entryStream = entry.OpenEntryStream()) { - for (var i = 0; i < 100; i++) - { - using (var memoryStream = new MemoryStream()) - using (Stream entryStream = entry.OpenEntryStream()) - { - entryStream.CopyTo(memoryStream); - } - } + await entryStream.CopyToAsync(memoryStream); } } } } [SkippableFact] - public void Zip_Evil_Throws_Exception() + public async ValueTask Zip_Evil_Throws_Exception() { //windows only because of the paths Skip.IfNot(Environment.OSVersion.Platform == PlatformID.Win32NT); string zipFile = Path.Combine(TEST_ARCHIVES_PATH, "Zip.Evil.zip"); - Assert.ThrowsAny(() => + await Assert.ThrowsAnyAsync(async () => { using (var archive = ZipArchive.Open(zipFile)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { - entry.WriteToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() + await entry.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, Overwrite = true diff --git a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs index 0b16ff2d..cc298b4c 100644 --- a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs @@ -19,21 +19,21 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Issue_269_Double_Skip() + public async ValueTask Issue_269_Double_Skip() { var path = Path.Combine(TEST_ARCHIVES_PATH, "PrePostHeaders.zip"); - using (Stream stream = new ForwardOnlyStream(File.OpenRead(path))) - using (IReader reader = ReaderFactory.Open(stream)) + await using (Stream stream = new ForwardOnlyStream(File.OpenRead(path))) + await using (IReader reader = await ReaderFactory.OpenAsync(stream)) { int count = 0; - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { count++; if (!reader.Entry.IsDirectory) { if (count % 2 != 0) { - reader.WriteEntryTo(Stream.Null); + await reader.WriteEntryToAsync(Stream.Null); } } } @@ -41,52 +41,52 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Zip64_Streamed_Read() + public async ValueTask Zip_Zip64_Streamed_Read() { - Read("Zip.zip64.zip", CompressionType.Deflate); + await ReadAsync("Zip.zip64.zip", CompressionType.Deflate); } [Fact] - public void Zip_ZipX_Streamed_Read() + public async ValueTask Zip_ZipX_Streamed_Read() { - Read("Zip.zipx", CompressionType.LZMA); + await ReadAsync("Zip.zipx", CompressionType.LZMA); } [Fact] - public void Zip_BZip2_Streamed_Read() + public async ValueTask Zip_BZip2_Streamed_Read() { - Read("Zip.bzip2.dd.zip", CompressionType.BZip2); + await ReadAsync("Zip.bzip2.dd.zip", CompressionType.BZip2); } [Fact] - public void Zip_BZip2_Read() + public async ValueTask Zip_BZip2_Read() { - Read("Zip.bzip2.zip", CompressionType.BZip2); + await ReadAsync("Zip.bzip2.zip", CompressionType.BZip2); } [Fact] - public void Zip_Deflate_Streamed2_Read() + public async ValueTask Zip_Deflate_Streamed2_Read() { - Read("Zip.deflate.dd-.zip", CompressionType.Deflate); + await ReadAsync("Zip.deflate.dd-.zip", CompressionType.Deflate); } [Fact] - public void Zip_Deflate_Streamed_Read() + public async ValueTask Zip_Deflate_Streamed_Read() { - Read("Zip.deflate.dd.zip", CompressionType.Deflate); + await ReadAsync("Zip.deflate.dd.zip", CompressionType.Deflate); } [Fact] - public void Zip_Deflate_Streamed_Skip() + public async ValueTask Zip_Deflate_Streamed_Skip() { - using (Stream stream = new ForwardOnlyStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")))) - using (IReader reader = ReaderFactory.Open(stream)) + await using (Stream stream = new ForwardOnlyStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")))) + await using (IReader reader = await ReaderFactory.OpenAsync(stream)) { int x = 0; - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { x++; if (x % 2 == 0) { - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -98,64 +98,64 @@ namespace SharpCompress.Test.Zip } } [Fact] - public void Zip_Deflate_Read() + public async ValueTask Zip_Deflate_Read() { - Read("Zip.deflate.zip", CompressionType.Deflate); + await ReadAsync("Zip.deflate.zip", CompressionType.Deflate); } [Fact] - public void Zip_Deflate64_Read() + public async ValueTask Zip_Deflate64_Read() { - Read("Zip.deflate64.zip", CompressionType.Deflate64); + await ReadAsync("Zip.deflate64.zip", CompressionType.Deflate64); } [Fact] - public void Zip_LZMA_Streamed_Read() + public async ValueTask Zip_LZMA_Streamed_Read() { - Read("Zip.lzma.dd.zip", CompressionType.LZMA); + await ReadAsync("Zip.lzma.dd.zip", CompressionType.LZMA); } [Fact] - public void Zip_LZMA_Read() + public async ValueTask Zip_LZMA_Read() { - Read("Zip.lzma.zip", CompressionType.LZMA); + await ReadAsync("Zip.lzma.zip", CompressionType.LZMA); } [Fact] - public void Zip_PPMd_Streamed_Read() + public async ValueTask Zip_PPMd_Streamed_Read() { - Read("Zip.ppmd.dd.zip", CompressionType.PPMd); + await ReadAsync("Zip.ppmd.dd.zip", CompressionType.PPMd); } [Fact] - public void Zip_PPMd_Read() + public async ValueTask Zip_PPMd_Read() { - Read("Zip.ppmd.zip", CompressionType.PPMd); + await ReadAsync("Zip.ppmd.zip", CompressionType.PPMd); } [Fact] - public void Zip_None_Read() + public async ValueTask Zip_None_Read() { - Read("Zip.none.zip", CompressionType.None); + await ReadAsync("Zip.none.zip", CompressionType.None); } [Fact] - public void Zip_Deflate_NoEmptyDirs_Read() + public async ValueTask Zip_Deflate_NoEmptyDirs_Read() { - Read("Zip.deflate.noEmptyDirs.zip", CompressionType.Deflate); + await ReadAsync("Zip.deflate.noEmptyDirs.zip", CompressionType.Deflate); } [Fact] - public void Zip_BZip2_PkwareEncryption_Read() + public async ValueTask Zip_BZip2_PkwareEncryption_Read() { - using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip"))) - using (var reader = ZipReader.Open(stream, new ReaderOptions() + await using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip"))) + await using (var reader = ZipReader.Open(stream, new ReaderOptions() { Password = "test" })) { - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { Assert.Equal(CompressionType.BZip2, reader.Entry.CompressionType); - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, Overwrite = true @@ -167,17 +167,17 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Reader_Disposal_Test() + public async ValueTask Zip_Reader_Disposal_Test() { - using (TestStream stream = new TestStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")))) + await using (TestStream stream = new TestStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")))) { - using (var reader = ReaderFactory.Open(stream)) + await using (var reader = await ReaderFactory.OpenAsync(stream)) { - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -191,16 +191,16 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Reader_Disposal_Test2() + public async ValueTask Zip_Reader_Disposal_Test2() { using (TestStream stream = new TestStream(File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")))) { - var reader = ReaderFactory.Open(stream); - while (reader.MoveToNextEntry()) + var reader = await ReaderFactory.OpenAsync(stream); + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -213,25 +213,25 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_LZMA_WinzipAES_Read() + public async ValueTask Zip_LZMA_WinzipAES_Read() { - Assert.Throws(() => + await Assert.ThrowsAsync(async () => { using ( Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.lzma.WinzipAES.zip"))) - using (var reader = ZipReader.Open(stream, new ReaderOptions() + await using (var reader = ZipReader.Open(stream, new ReaderOptions() { Password = "test" })) { - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { Assert.Equal(CompressionType.Unknown, reader.Entry.CompressionType); - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -245,20 +245,20 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_Deflate_WinzipAES_Read() + public async ValueTask Zip_Deflate_WinzipAES_Read() { - using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"))) - using (var reader = ZipReader.Open(stream, new ReaderOptions() + await using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"))) + await using (var reader = ZipReader.Open(stream, new ReaderOptions() { Password = "test" })) { - while (reader.MoveToNextEntry()) + while (await reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) { Assert.Equal(CompressionType.Unknown, reader.Entry.CompressionType); - reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, + await reader.WriteEntryToDirectoryAsync(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, @@ -292,10 +292,10 @@ namespace SharpCompress.Test.Zip stream = new MemoryStream(memory.ToArray()); await File.WriteAllBytesAsync(Path.Combine(SCRATCH_FILES_PATH, "foo.zip"), memory.ToArray()); - using (IReader zipReader = ZipReader.Open(new NonDisposingStream(stream, true))) + await using (IReader zipReader = ZipReader.Open(new NonDisposingStream(stream, true))) { var i = 0; - while (zipReader.MoveToNextEntry()) + while (await zipReader.MoveToNextEntry()) { await using (EntryStream entry = zipReader.OpenEntryStream()) { @@ -318,16 +318,16 @@ namespace SharpCompress.Test.Zip } [Fact] - public void Zip_None_Issue86_Streamed_Read() + public async ValueTask Zip_None_Issue86_Streamed_Read() { var keys = new string[] { "Empty1", "Empty2", "Dir1/", "Dir2/", "Fake1", "Fake2", "Internal.zip" }; using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.issue86.zip"))) - using (var reader = ZipReader.Open(stream)) + await using (var reader = ZipReader.Open(stream)) { foreach (var key in keys) { - reader.MoveToNextEntry(); + await reader.MoveToNextEntry(); Assert.Equal(reader.Entry.Key, key); @@ -337,7 +337,7 @@ namespace SharpCompress.Test.Zip } } - Assert.False(reader.MoveToNextEntry()); + Assert.False(await reader.MoveToNextEntry()); } }