From 7b76858ae1275568771c7ffddfe5b89022979d8e Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Thu, 15 Jan 2026 11:41:30 +0000 Subject: [PATCH] refactoring naming again --- src/SharpCompress/Archives/ArchiveFactory.cs | 54 ++++++++-------- .../Archives/AutoArchiveFactory.cs | 16 ++--- .../Archives/GZip/GZipArchive.Factory.cs | 37 ++++++----- src/SharpCompress/Archives/IArchiveFactory.cs | 8 +-- .../Archives/IArchiveOpenable.cs | 15 +++-- .../Archives/IMultiArchiveFactory.cs | 11 ++-- .../Archives/IMultiArchiveOpenable.cs | 8 +-- .../Archives/IWriteableArchiveFactory.cs | 2 +- .../Archives/Rar/RarArchive.Factory.cs | 33 +++++----- .../SevenZip/SevenZipArchive.Factory.cs | 35 ++++++----- .../Archives/Tar/TarArchive.Factory.cs | 37 ++++++----- .../Archives/Zip/ZipArchive.Factory.cs | 37 ++++++----- src/SharpCompress/Factories/GZipFactory.cs | 48 +++++++------- src/SharpCompress/Factories/RarFactory.cs | 40 ++++++------ .../Factories/SevenZipFactory.cs | 40 ++++++------ src/SharpCompress/Factories/TarFactory.cs | 48 +++++++------- src/SharpCompress/Factories/ZipFactory.cs | 48 +++++++------- src/SharpCompress/Readers/ReaderFactory.cs | 20 +++--- .../Writers/GZip/GZipWriter.Factory.cs | 20 +++--- src/SharpCompress/Writers/IWriterFactory.cs | 4 +- src/SharpCompress/Writers/IWriterOpenable.cs | 12 ++-- .../Writers/Tar/TarWriter.Factory.cs | 20 +++--- src/SharpCompress/Writers/WriterFactory.cs | 14 ++--- .../Writers/Zip/ZipWriter.Factory.cs | 20 +++--- tests/SharpCompress.Performance/Program.cs | 4 +- .../SharpCompress.Test/Ace/AceReaderTests.cs | 2 +- tests/SharpCompress.Test/ArchiveTests.cs | 56 ++++++++++------- .../SharpCompress.Test/Arj/ArjReaderTests.cs | 2 +- .../BZip2/BZip2ReaderTests.cs | 2 +- tests/SharpCompress.Test/ExtractAll.cs | 4 +- .../ExtractAllEntriesTests.cs | 4 +- tests/SharpCompress.Test/ExtractionTests.cs | 8 +-- tests/SharpCompress.Test/GZip/AsyncTests.cs | 14 ++--- .../GZip/GZipArchiveAsyncTests.cs | 12 ++-- .../GZip/GZipArchiveDirectoryTests.cs | 2 +- .../GZip/GZipArchiveTests.cs | 14 ++--- .../GZip/GZipReaderAsyncTests.cs | 4 +- .../GZip/GZipReaderTests.cs | 2 +- .../GZip/GZipWriterAsyncTests.cs | 4 +- .../GZip/GZipWriterTests.cs | 4 +- .../SharpCompress.Test/ProgressReportTests.cs | 22 +++---- .../Rar/RarArchiveAsyncTests.cs | 40 ++++++------ .../SharpCompress.Test/Rar/RarArchiveTests.cs | 36 +++++------ .../Rar/RarReaderAsyncTests.cs | 18 +++--- .../SharpCompress.Test/Rar/RarReaderTests.cs | 20 +++--- tests/SharpCompress.Test/ReaderTests.cs | 8 +-- .../SevenZip/SevenZipArchiveAsyncTests.cs | 20 +++--- .../SevenZip/SevenZipArchiveTests.cs | 12 ++-- .../Streams/ZLibBaseStreamAsyncTests.cs | 4 +- .../Streams/ZlibBaseStreamTests.cs | 4 +- .../Tar/TarArchiveAsyncTests.cs | 18 +++--- .../Tar/TarArchiveDirectoryTests.cs | 12 ++-- .../SharpCompress.Test/Tar/TarArchiveTests.cs | 26 ++++---- .../Tar/TarReaderAsyncTests.cs | 20 +++--- .../SharpCompress.Test/Tar/TarReaderTests.cs | 22 +++---- .../Tar/TarWriterDirectoryTests.cs | 12 ++-- tests/SharpCompress.Test/TestBase.cs | 4 +- tests/SharpCompress.Test/WriterTests.cs | 12 ++-- .../SharpCompress.Test/Zip/Zip64AsyncTests.cs | 6 +- tests/SharpCompress.Test/Zip/Zip64Tests.cs | 6 +- .../Zip/Zip64VersionConsistencyTests.cs | 10 +-- .../Zip/ZipArchiveAsyncTests.cs | 12 ++-- .../Zip/ZipArchiveDirectoryTests.cs | 12 ++-- .../SharpCompress.Test/Zip/ZipArchiveTests.cs | 62 +++++++++---------- .../Zip/ZipMemoryArchiveWithCrcAsyncTests.cs | 8 +-- .../Zip/ZipMemoryArchiveWithCrcTests.cs | 6 +- .../Zip/ZipReaderAsyncTests.cs | 16 ++--- .../SharpCompress.Test/Zip/ZipReaderTests.cs | 40 ++++++------ .../Zip/ZipWriterDirectoryTests.cs | 12 ++-- .../SharpCompress.Test/Zip/ZipWriterTests.cs | 4 +- 70 files changed, 661 insertions(+), 608 deletions(-) diff --git a/src/SharpCompress/Archives/ArchiveFactory.cs b/src/SharpCompress/Archives/ArchiveFactory.cs index 8d4b9c27..d94786e7 100644 --- a/src/SharpCompress/Archives/ArchiveFactory.cs +++ b/src/SharpCompress/Archives/ArchiveFactory.cs @@ -13,14 +13,14 @@ namespace SharpCompress.Archives; public static class ArchiveFactory { - public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null) + public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) { readerOptions ??= new ReaderOptions(); stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize); - return FindFactory(stream).Open(stream, readerOptions); + return FindFactory(stream).OpenArchive(stream, readerOptions); } - public static async ValueTask OpenAsync( + public static async ValueTask OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default @@ -29,10 +29,10 @@ public static class ArchiveFactory readerOptions ??= new ReaderOptions(); stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize); var factory = await FindFactoryAsync(stream, cancellationToken); - return factory.OpenAsync(stream, readerOptions); + return factory.OpenAsyncArchive(stream, readerOptions); } - public static IWritableArchive Create(ArchiveType type) + public static IWritableArchive CreateArchive(ArchiveType type) { var factory = Factory .Factories.OfType() @@ -40,36 +40,36 @@ public static class ArchiveFactory if (factory != null) { - return factory.CreateWriteableArchive(); + return factory.CreateArchive(); } throw new NotSupportedException("Cannot create Archives of type: " + type); } - public static IArchive Open(string filePath, ReaderOptions? options = null) + public static IArchive OpenArchive(string filePath, ReaderOptions? options = null) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), options); + return OpenArchive(new FileInfo(filePath), options); } - public static ValueTask OpenAsync( + public static ValueTask OpenAsyncArchive( string filePath, ReaderOptions? options = null, CancellationToken cancellationToken = default ) { filePath.NotNullOrEmpty(nameof(filePath)); - return OpenAsync(new FileInfo(filePath), options, cancellationToken); + return OpenAsyncArchive(new FileInfo(filePath), options, cancellationToken); } - public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null) + public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null) { options ??= new ReaderOptions { LeaveStreamOpen = false }; - return FindFactory(fileInfo).Open(fileInfo, options); + return FindFactory(fileInfo).OpenArchive(fileInfo, options); } - public static async ValueTask OpenAsync( + public static async ValueTask OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? options = null, CancellationToken cancellationToken = default @@ -78,10 +78,10 @@ public static class ArchiveFactory options ??= new ReaderOptions { LeaveStreamOpen = false }; var factory = await FindFactoryAsync(fileInfo, cancellationToken); - return factory.OpenAsync(fileInfo, options, cancellationToken); + return factory.OpenAsyncArchive(fileInfo, options, cancellationToken); } - public static IArchive Open(IEnumerable fileInfos, ReaderOptions? options = null) + public static IArchive OpenArchive(IEnumerable fileInfos, ReaderOptions? options = null) { fileInfos.NotNull(nameof(fileInfos)); var filesArray = fileInfos.ToArray(); @@ -93,16 +93,16 @@ public static class ArchiveFactory var fileInfo = filesArray[0]; if (filesArray.Length == 1) { - return Open(fileInfo, options); + return OpenArchive(fileInfo, options); } fileInfo.NotNull(nameof(fileInfo)); options ??= new ReaderOptions { LeaveStreamOpen = false }; - return FindFactory(fileInfo).Open(filesArray, options); + return FindFactory(fileInfo).OpenArchive(filesArray, options); } - public static async ValueTask OpenAsync( + public static async ValueTask OpenAsyncArchive( IEnumerable fileInfos, ReaderOptions? options = null, CancellationToken cancellationToken = default @@ -118,17 +118,17 @@ public static class ArchiveFactory var fileInfo = filesArray[0]; if (filesArray.Length == 1) { - return await OpenAsync(fileInfo, options, cancellationToken); + return await OpenAsyncArchive(fileInfo, options, cancellationToken); } fileInfo.NotNull(nameof(fileInfo)); options ??= new ReaderOptions { LeaveStreamOpen = false }; var factory = await FindFactoryAsync(fileInfo, cancellationToken); - return factory.OpenAsync(filesArray, options, cancellationToken); + return factory.OpenAsyncArchive(filesArray, options, cancellationToken); } - public static IArchive Open(IEnumerable streams, ReaderOptions? options = null) + public static IArchive OpenArchive(IEnumerable streams, ReaderOptions? options = null) { streams.NotNull(nameof(streams)); var streamsArray = streams.ToArray(); @@ -140,16 +140,16 @@ public static class ArchiveFactory var firstStream = streamsArray[0]; if (streamsArray.Length == 1) { - return Open(firstStream, options); + return OpenArchive(firstStream, options); } firstStream.NotNull(nameof(firstStream)); options ??= new ReaderOptions(); - return FindFactory(firstStream).Open(streamsArray, options); + return FindFactory(firstStream).OpenArchive(streamsArray, options); } - public static async ValueTask OpenAsync( + public static async ValueTask OpenAsyncArchive( IEnumerable streams, ReaderOptions? options = null, CancellationToken cancellationToken = default @@ -166,14 +166,14 @@ public static class ArchiveFactory var firstStream = streamsArray[0]; if (streamsArray.Length == 1) { - return await OpenAsync(firstStream, options, cancellationToken); + return await OpenAsyncArchive(firstStream, options, cancellationToken); } firstStream.NotNull(nameof(firstStream)); options ??= new ReaderOptions(); var factory = FindFactory(firstStream); - return factory.OpenAsync(streamsArray, options); + return factory.OpenAsyncArchive(streamsArray, options); } public static void WriteToDirectory( @@ -182,7 +182,7 @@ public static class ArchiveFactory ExtractionOptions? options = null ) { - using var archive = Open(sourceArchive); + using var archive = OpenArchive(sourceArchive); archive.WriteToDirectory(destinationDirectory, options); } diff --git a/src/SharpCompress/Archives/AutoArchiveFactory.cs b/src/SharpCompress/Archives/AutoArchiveFactory.cs index c92c305f..f588b085 100644 --- a/src/SharpCompress/Archives/AutoArchiveFactory.cs +++ b/src/SharpCompress/Archives/AutoArchiveFactory.cs @@ -31,22 +31,22 @@ internal class AutoArchiveFactory : IArchiveFactory public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException(); - public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) => - ArchiveFactory.Open(stream, readerOptions); + public IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) => + ArchiveFactory.OpenArchive(stream, readerOptions); - public IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null) => - (IAsyncArchive)Open(stream, readerOptions); + public IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null) => + (IAsyncArchive)OpenArchive(stream, readerOptions); - public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) => - ArchiveFactory.Open(fileInfo, readerOptions); + public IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) => + ArchiveFactory.OpenArchive(fileInfo, readerOptions); - public IAsyncArchive OpenAsync( + public IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } } diff --git a/src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs b/src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs index b2053faa..16092968 100644 --- a/src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs +++ b/src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs @@ -20,7 +20,7 @@ public partial class GZipArchive IMultiArchiveOpenable #endif { - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( string path, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default @@ -28,19 +28,22 @@ public partial class GZipArchive { cancellationToken.ThrowIfCancellationRequested(); path.NotNullOrEmpty(nameof(path)); - return (IWritableAsyncArchive)Open( + return (IWritableAsyncArchive)OpenArchive( new FileInfo(path), readerOptions ?? new ReaderOptions() ); } - public static IWritableArchive Open(string filePath, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); + return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); } - public static IWritableArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive( + FileInfo fileInfo, + ReaderOptions? readerOptions = null + ) { fileInfo.NotNull(nameof(fileInfo)); return new GZipArchive( @@ -52,7 +55,7 @@ public partial class GZipArchive ); } - public static IWritableArchive Open( + public static IWritableArchive OpenArchive( IEnumerable fileInfos, ReaderOptions? readerOptions = null ) @@ -68,7 +71,7 @@ public partial class GZipArchive ); } - public static IWritableArchive Open( + public static IWritableArchive OpenArchive( IEnumerable streams, ReaderOptions? readerOptions = null ) @@ -84,7 +87,7 @@ public partial class GZipArchive ); } - public static IWritableArchive Open(Stream stream, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) { stream.NotNull(nameof(stream)); @@ -98,47 +101,47 @@ public partial class GZipArchive ); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(stream, readerOptions); + return (IWritableAsyncArchive)OpenArchive(stream, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(fileInfo, readerOptions); + return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(streams, readerOptions); + return (IWritableAsyncArchive)OpenArchive(streams, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(fileInfos, readerOptions); + return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions); } - public static GZipArchive Create() => new(); + public static GZipArchive CreateArchive() => new(); public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath)); diff --git a/src/SharpCompress/Archives/IArchiveFactory.cs b/src/SharpCompress/Archives/IArchiveFactory.cs index b94128d6..eb80e072 100644 --- a/src/SharpCompress/Archives/IArchiveFactory.cs +++ b/src/SharpCompress/Archives/IArchiveFactory.cs @@ -25,21 +25,21 @@ public interface IArchiveFactory : IFactory /// /// An open, readable and seekable stream. /// reading options. - IArchive Open(Stream stream, ReaderOptions? readerOptions = null); + IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null); /// /// Opens an Archive for random access asynchronously. /// /// An open, readable and seekable stream. /// reading options. - IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null); + IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null); /// /// Constructor with a FileInfo object to an existing file. /// /// the file to open. /// reading options. - IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null); + IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null); /// /// Opens an Archive from a FileInfo object asynchronously. @@ -47,7 +47,7 @@ public interface IArchiveFactory : IFactory /// the file to open. /// reading options. /// Cancellation token. - IAsyncArchive OpenAsync( + IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Archives/IArchiveOpenable.cs b/src/SharpCompress/Archives/IArchiveOpenable.cs index cf606a65..d884aed0 100644 --- a/src/SharpCompress/Archives/IArchiveOpenable.cs +++ b/src/SharpCompress/Archives/IArchiveOpenable.cs @@ -9,25 +9,28 @@ public interface IArchiveOpenable where TSync : IArchive where TASync : IAsyncArchive { - public static abstract TSync Open(string filePath, ReaderOptions? readerOptions = null); + public static abstract TSync OpenArchive(string filePath, ReaderOptions? readerOptions = null); - public static abstract TSync Open(FileInfo fileInfo, ReaderOptions? readerOptions = null); + public static abstract TSync OpenArchive( + FileInfo fileInfo, + ReaderOptions? readerOptions = null + ); - public static abstract TSync Open(Stream stream, ReaderOptions? readerOptions = null); + public static abstract TSync OpenArchive(Stream stream, ReaderOptions? readerOptions = null); - public static abstract TASync OpenAsync( + public static abstract TASync OpenAsyncArchive( string path, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ); - public static abstract TASync OpenAsync( + public static abstract TASync OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ); - public static abstract TASync OpenAsync( + public static abstract TASync OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Archives/IMultiArchiveFactory.cs b/src/SharpCompress/Archives/IMultiArchiveFactory.cs index e0064cc0..fc418ad4 100644 --- a/src/SharpCompress/Archives/IMultiArchiveFactory.cs +++ b/src/SharpCompress/Archives/IMultiArchiveFactory.cs @@ -26,21 +26,24 @@ public interface IMultiArchiveFactory : IFactory /// /// /// reading options. - IArchive Open(IReadOnlyList streams, ReaderOptions? readerOptions = null); + IArchive OpenArchive(IReadOnlyList streams, ReaderOptions? readerOptions = null); /// /// Opens a multi-part archive from streams asynchronously. /// /// /// reading options. - IAsyncArchive OpenAsync(IReadOnlyList streams, ReaderOptions? readerOptions = null); + IAsyncArchive OpenAsyncArchive( + IReadOnlyList streams, + ReaderOptions? readerOptions = null + ); /// /// Constructor with IEnumerable Stream objects, multi and split support. /// /// /// reading options. - IArchive Open(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null); + IArchive OpenArchive(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null); /// /// Opens a multi-part archive from files asynchronously. @@ -48,7 +51,7 @@ public interface IMultiArchiveFactory : IFactory /// /// reading options. /// Cancellation token. - IAsyncArchive OpenAsync( + IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Archives/IMultiArchiveOpenable.cs b/src/SharpCompress/Archives/IMultiArchiveOpenable.cs index 06c5bdd3..53f375c0 100644 --- a/src/SharpCompress/Archives/IMultiArchiveOpenable.cs +++ b/src/SharpCompress/Archives/IMultiArchiveOpenable.cs @@ -10,23 +10,23 @@ public interface IMultiArchiveOpenable where TSync : IArchive where TASync : IAsyncArchive { - public static abstract TSync Open( + public static abstract TSync OpenArchive( IEnumerable fileInfos, ReaderOptions? readerOptions = null ); - public static abstract TSync Open( + public static abstract TSync OpenArchive( IEnumerable streams, ReaderOptions? readerOptions = null ); - public static abstract TASync OpenAsync( + public static abstract TASync OpenAsyncArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ); - public static abstract TASync OpenAsync( + public static abstract TASync OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Archives/IWriteableArchiveFactory.cs b/src/SharpCompress/Archives/IWriteableArchiveFactory.cs index 4fae9f55..f1de642d 100644 --- a/src/SharpCompress/Archives/IWriteableArchiveFactory.cs +++ b/src/SharpCompress/Archives/IWriteableArchiveFactory.cs @@ -16,5 +16,5 @@ public interface IWriteableArchiveFactory : Factories.IFactory /// Creates a new, empty archive, ready to be written. /// /// - IWritableArchive CreateWriteableArchive(); + IWritableArchive CreateArchive(); } diff --git a/src/SharpCompress/Archives/Rar/RarArchive.Factory.cs b/src/SharpCompress/Archives/Rar/RarArchive.Factory.cs index 6ede4790..f3e9a99d 100644 --- a/src/SharpCompress/Archives/Rar/RarArchive.Factory.cs +++ b/src/SharpCompress/Archives/Rar/RarArchive.Factory.cs @@ -19,7 +19,7 @@ public partial class RarArchive IMultiArchiveOpenable #endif { - public static IRarAsyncArchive OpenAsync( + public static IRarAsyncArchive OpenAsyncArchive( string path, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default @@ -27,10 +27,10 @@ public partial class RarArchive { cancellationToken.ThrowIfCancellationRequested(); path.NotNullOrEmpty(nameof(path)); - return (IRarAsyncArchive)Open(new FileInfo(path), readerOptions); + return (IRarAsyncArchive)OpenArchive(new FileInfo(path), readerOptions); } - public static IRarArchive Open(string filePath, ReaderOptions? options = null) + public static IRarArchive OpenArchive(string filePath, ReaderOptions? options = null) { filePath.NotNullOrEmpty(nameof(filePath)); var fileInfo = new FileInfo(filePath); @@ -43,7 +43,7 @@ public partial class RarArchive ); } - public static IRarArchive Open(FileInfo fileInfo, ReaderOptions? options = null) + public static IRarArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null) { fileInfo.NotNull(nameof(fileInfo)); return new RarArchive( @@ -55,7 +55,7 @@ public partial class RarArchive ); } - public static IRarArchive Open(Stream stream, ReaderOptions? options = null) + public static IRarArchive OpenArchive(Stream stream, ReaderOptions? options = null) { stream.NotNull(nameof(stream)); @@ -67,7 +67,7 @@ public partial class RarArchive return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions())); } - public static IRarArchive Open( + public static IRarArchive OpenArchive( IEnumerable fileInfos, ReaderOptions? readerOptions = null ) @@ -83,7 +83,10 @@ public partial class RarArchive ); } - public static IRarArchive Open(IEnumerable streams, ReaderOptions? readerOptions = null) + public static IRarArchive OpenArchive( + IEnumerable streams, + ReaderOptions? readerOptions = null + ) { streams.NotNull(nameof(streams)); var strms = streams.ToArray(); @@ -96,44 +99,44 @@ public partial class RarArchive ); } - public static IRarAsyncArchive OpenAsync( + public static IRarAsyncArchive OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IRarAsyncArchive)Open(stream, readerOptions); + return (IRarAsyncArchive)OpenArchive(stream, readerOptions); } - public static IRarAsyncArchive OpenAsync( + public static IRarAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IRarAsyncArchive)Open(fileInfo, readerOptions); + return (IRarAsyncArchive)OpenArchive(fileInfo, readerOptions); } - public static IRarAsyncArchive OpenAsync( + public static IRarAsyncArchive OpenAsyncArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IRarAsyncArchive)Open(streams, readerOptions); + return (IRarAsyncArchive)OpenArchive(streams, readerOptions); } - public static IRarAsyncArchive OpenAsync( + public static IRarAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IRarAsyncArchive)Open(fileInfos, readerOptions); + return (IRarAsyncArchive)OpenArchive(fileInfos, readerOptions); } public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath)); diff --git a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs index 3b39cff4..2abb00ab 100644 --- a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs +++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs @@ -18,7 +18,7 @@ public partial class SevenZipArchive IMultiArchiveOpenable #endif { - public static IAsyncArchive OpenAsync( + public static IAsyncArchive OpenAsyncArchive( string path, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default @@ -26,16 +26,16 @@ public partial class SevenZipArchive { cancellationToken.ThrowIfCancellationRequested(); path.NotNullOrEmpty("path"); - return (IAsyncArchive)Open(new FileInfo(path), readerOptions ?? new ReaderOptions()); + return (IAsyncArchive)OpenArchive(new FileInfo(path), readerOptions ?? new ReaderOptions()); } - public static IArchive Open(string filePath, ReaderOptions? readerOptions = null) + public static IArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null) { filePath.NotNullOrEmpty("filePath"); - return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); + return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); } - public static IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) + public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) { fileInfo.NotNull("fileInfo"); return new SevenZipArchive( @@ -47,7 +47,7 @@ public partial class SevenZipArchive ); } - public static IArchive Open( + public static IArchive OpenArchive( IEnumerable fileInfos, ReaderOptions? readerOptions = null ) @@ -63,7 +63,10 @@ public partial class SevenZipArchive ); } - public static IArchive Open(IEnumerable streams, ReaderOptions? readerOptions = null) + public static IArchive OpenArchive( + IEnumerable streams, + ReaderOptions? readerOptions = null + ) { streams.NotNull(nameof(streams)); var strms = streams.ToArray(); @@ -76,7 +79,7 @@ public partial class SevenZipArchive ); } - public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null) + public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) { stream.NotNull("stream"); @@ -90,44 +93,44 @@ public partial class SevenZipArchive ); } - public static IAsyncArchive OpenAsync( + public static IAsyncArchive OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(stream, readerOptions); + return (IAsyncArchive)OpenArchive(stream, readerOptions); } - public static IAsyncArchive OpenAsync( + public static IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } - public static IAsyncArchive OpenAsync( + public static IAsyncArchive OpenAsyncArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(streams, readerOptions); + return (IAsyncArchive)OpenArchive(streams, readerOptions); } - public static IAsyncArchive OpenAsync( + public static IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfos, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfos, readerOptions); } public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath)); diff --git a/src/SharpCompress/Archives/Tar/TarArchive.Factory.cs b/src/SharpCompress/Archives/Tar/TarArchive.Factory.cs index adf12909..5ce2d944 100644 --- a/src/SharpCompress/Archives/Tar/TarArchive.Factory.cs +++ b/src/SharpCompress/Archives/Tar/TarArchive.Factory.cs @@ -20,13 +20,16 @@ public partial class TarArchive IMultiArchiveOpenable #endif { - public static IWritableArchive Open(string filePath, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); + return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); } - public static IWritableArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive( + FileInfo fileInfo, + ReaderOptions? readerOptions = null + ) { fileInfo.NotNull(nameof(fileInfo)); return new TarArchive( @@ -38,7 +41,7 @@ public partial class TarArchive ); } - public static IWritableArchive Open( + public static IWritableArchive OpenArchive( IEnumerable fileInfos, ReaderOptions? readerOptions = null ) @@ -54,7 +57,7 @@ public partial class TarArchive ); } - public static IWritableArchive Open( + public static IWritableArchive OpenArchive( IEnumerable streams, ReaderOptions? readerOptions = null ) @@ -70,7 +73,7 @@ public partial class TarArchive ); } - public static IWritableArchive Open(Stream stream, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) { stream.NotNull(nameof(stream)); @@ -84,54 +87,54 @@ public partial class TarArchive ); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(stream, readerOptions); + return (IWritableAsyncArchive)OpenArchive(stream, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( string path, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(new FileInfo(path), readerOptions); + return (IWritableAsyncArchive)OpenArchive(new FileInfo(path), readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(fileInfo, readerOptions); + return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(streams, readerOptions); + return (IWritableAsyncArchive)OpenArchive(streams, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(fileInfos, readerOptions); + return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions); } public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath)); @@ -162,5 +165,5 @@ public partial class TarArchive return false; } - public static TarArchive Create() => new(); + public static TarArchive CreateArchive() => new(); } diff --git a/src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs b/src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs index 770fe048..85110f12 100644 --- a/src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs +++ b/src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs @@ -18,13 +18,16 @@ public partial class ZipArchive IMultiArchiveOpenable #endif { - public static IWritableArchive Open(string filePath, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); + return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions()); } - public static IWritableArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive( + FileInfo fileInfo, + ReaderOptions? readerOptions = null + ) { fileInfo.NotNull(nameof(fileInfo)); return new ZipArchive( @@ -36,7 +39,7 @@ public partial class ZipArchive ); } - public static IWritableArchive Open( + public static IWritableArchive OpenArchive( IEnumerable fileInfos, ReaderOptions? readerOptions = null ) @@ -52,7 +55,7 @@ public partial class ZipArchive ); } - public static IWritableArchive Open( + public static IWritableArchive OpenArchive( IEnumerable streams, ReaderOptions? readerOptions = null ) @@ -68,7 +71,7 @@ public partial class ZipArchive ); } - public static IWritableArchive Open(Stream stream, ReaderOptions? readerOptions = null) + public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) { stream.NotNull(nameof(stream)); @@ -82,54 +85,54 @@ public partial class ZipArchive ); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( string path, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(path, readerOptions); + return (IWritableAsyncArchive)OpenArchive(path, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(stream, readerOptions); + return (IWritableAsyncArchive)OpenArchive(stream, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(fileInfo, readerOptions); + return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(streams, readerOptions); + return (IWritableAsyncArchive)OpenArchive(streams, readerOptions); } - public static IWritableAsyncArchive OpenAsync( + public static IWritableAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IWritableAsyncArchive)Open(fileInfos, readerOptions); + return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions); } public static bool IsZipFile( @@ -263,7 +266,7 @@ public partial class ZipArchive } } - public static ZipArchive Create() => new(); + public static ZipArchive CreateArchive() => new(); public static async ValueTask IsZipMultiAsync( Stream stream, diff --git a/src/SharpCompress/Factories/GZipFactory.cs b/src/SharpCompress/Factories/GZipFactory.cs index f222fc31..c7898b68 100644 --- a/src/SharpCompress/Factories/GZipFactory.cs +++ b/src/SharpCompress/Factories/GZipFactory.cs @@ -61,12 +61,12 @@ public class GZipFactory #region IArchiveFactory /// - public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) => - GZipArchive.Open(stream, readerOptions); + public IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) => + GZipArchive.OpenArchive(stream, readerOptions); /// - public IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null) => - (IAsyncArchive)Open(stream, readerOptions); + public IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null) => + (IAsyncArchive)OpenArchive(stream, readerOptions); public override ValueTask IsArchiveAsync( Stream stream, @@ -75,14 +75,14 @@ public class GZipFactory ) => new(IsArchive(stream, password, bufferSize)); /// - public IAsyncArchive OpenAsync( + public IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } #endregion @@ -90,28 +90,32 @@ public class GZipFactory #region IMultiArchiveFactory /// - public IArchive Open(IReadOnlyList streams, ReaderOptions? readerOptions = null) => - GZipArchive.Open(streams, readerOptions); - - /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null - ) => (IAsyncArchive)Open(streams, readerOptions); + ) => GZipArchive.OpenArchive(streams, readerOptions); /// - public IArchive Open(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null) => - GZipArchive.Open(fileInfos, readerOptions); + public IAsyncArchive OpenAsyncArchive( + IReadOnlyList streams, + ReaderOptions? readerOptions = null + ) => (IAsyncArchive)OpenArchive(streams, readerOptions); /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( + IReadOnlyList fileInfos, + ReaderOptions? readerOptions = null + ) => GZipArchive.OpenArchive(fileInfos, readerOptions); + + /// + public IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfos, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfos, readerOptions); } #endregion @@ -164,15 +168,15 @@ public class GZipFactory } /// - public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) => - GZipArchive.Open(fileInfo, readerOptions); + public IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) => + GZipArchive.OpenArchive(fileInfo, readerOptions); #endregion #region IWriterFactory /// - public IWriter Open(Stream stream, WriterOptions writerOptions) + public IWriter OpenWriter(Stream stream, WriterOptions writerOptions) { if (writerOptions.CompressionType != CompressionType.GZip) { @@ -182,7 +186,7 @@ public class GZipFactory } /// - public IAsyncWriter OpenAsync( + public IAsyncWriter OpenAsyncWriter( Stream stream, WriterOptions writerOptions, CancellationToken cancellationToken = default @@ -193,7 +197,7 @@ public class GZipFactory { throw new InvalidFormatException("GZip archives only support GZip compression type."); } - return (IAsyncWriter)Open(stream, writerOptions); + return (IAsyncWriter)OpenWriter(stream, writerOptions); } #endregion @@ -201,7 +205,7 @@ public class GZipFactory #region IWriteableArchiveFactory /// - public IWritableArchive CreateWriteableArchive() => GZipArchive.Create(); + public IWritableArchive CreateArchive() => GZipArchive.CreateArchive(); #endregion } diff --git a/src/SharpCompress/Factories/RarFactory.cs b/src/SharpCompress/Factories/RarFactory.cs index faf35ab5..7cc09e3c 100644 --- a/src/SharpCompress/Factories/RarFactory.cs +++ b/src/SharpCompress/Factories/RarFactory.cs @@ -46,26 +46,26 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade #region IArchiveFactory /// - public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) => - RarArchive.Open(stream, readerOptions); + public IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) => + RarArchive.OpenArchive(stream, readerOptions); /// - public IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null) => - (IAsyncArchive)Open(stream, readerOptions); + public IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null) => + (IAsyncArchive)OpenArchive(stream, readerOptions); /// - public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) => - RarArchive.Open(fileInfo, readerOptions); + public IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) => + RarArchive.OpenArchive(fileInfo, readerOptions); /// - public IAsyncArchive OpenAsync( + public IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } public override ValueTask IsArchiveAsync( @@ -79,28 +79,32 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade #region IMultiArchiveFactory /// - public IArchive Open(IReadOnlyList streams, ReaderOptions? readerOptions = null) => - RarArchive.Open(streams, readerOptions); - - /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null - ) => (IAsyncArchive)Open(streams, readerOptions); + ) => RarArchive.OpenArchive(streams, readerOptions); /// - public IArchive Open(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null) => - RarArchive.Open(fileInfos, readerOptions); + public IAsyncArchive OpenAsyncArchive( + IReadOnlyList streams, + ReaderOptions? readerOptions = null + ) => (IAsyncArchive)OpenArchive(streams, readerOptions); /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( + IReadOnlyList fileInfos, + ReaderOptions? readerOptions = null + ) => RarArchive.OpenArchive(fileInfos, readerOptions); + + /// + public IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfos, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfos, readerOptions); } #endregion diff --git a/src/SharpCompress/Factories/SevenZipFactory.cs b/src/SharpCompress/Factories/SevenZipFactory.cs index f430919a..c2ea69f1 100644 --- a/src/SharpCompress/Factories/SevenZipFactory.cs +++ b/src/SharpCompress/Factories/SevenZipFactory.cs @@ -41,26 +41,26 @@ public class SevenZipFactory : Factory, IArchiveFactory, IMultiArchiveFactory #region IArchiveFactory /// - public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) => - SevenZipArchive.Open(stream, readerOptions); + public IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) => + SevenZipArchive.OpenArchive(stream, readerOptions); /// - public IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null) => - (IAsyncArchive)Open(stream, readerOptions); + public IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null) => + (IAsyncArchive)OpenArchive(stream, readerOptions); /// - public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) => - SevenZipArchive.Open(fileInfo, readerOptions); + public IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) => + SevenZipArchive.OpenArchive(fileInfo, readerOptions); /// - public IAsyncArchive OpenAsync( + public IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } public override ValueTask IsArchiveAsync( @@ -74,28 +74,32 @@ public class SevenZipFactory : Factory, IArchiveFactory, IMultiArchiveFactory #region IMultiArchiveFactory /// - public IArchive Open(IReadOnlyList streams, ReaderOptions? readerOptions = null) => - SevenZipArchive.Open(streams, readerOptions); - - /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null - ) => (IAsyncArchive)Open(streams, readerOptions); + ) => SevenZipArchive.OpenArchive(streams, readerOptions); /// - public IArchive Open(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null) => - SevenZipArchive.Open(fileInfos, readerOptions); + public IAsyncArchive OpenAsyncArchive( + IReadOnlyList streams, + ReaderOptions? readerOptions = null + ) => (IAsyncArchive)OpenArchive(streams, readerOptions); /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( + IReadOnlyList fileInfos, + ReaderOptions? readerOptions = null + ) => SevenZipArchive.OpenArchive(fileInfos, readerOptions); + + /// + public IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfos, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfos, readerOptions); } #endregion diff --git a/src/SharpCompress/Factories/TarFactory.cs b/src/SharpCompress/Factories/TarFactory.cs index a664b243..35827ea0 100644 --- a/src/SharpCompress/Factories/TarFactory.cs +++ b/src/SharpCompress/Factories/TarFactory.cs @@ -72,26 +72,26 @@ public class TarFactory #region IArchiveFactory /// - public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) => - TarArchive.Open(stream, readerOptions); + public IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) => + TarArchive.OpenArchive(stream, readerOptions); /// - public IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null) => - (IAsyncArchive)Open(stream, readerOptions); + public IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null) => + (IAsyncArchive)OpenArchive(stream, readerOptions); /// - public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) => - TarArchive.Open(fileInfo, readerOptions); + public IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) => + TarArchive.OpenArchive(fileInfo, readerOptions); /// - public IAsyncArchive OpenAsync( + public IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } #endregion @@ -99,28 +99,32 @@ public class TarFactory #region IMultiArchiveFactory /// - public IArchive Open(IReadOnlyList streams, ReaderOptions? readerOptions = null) => - TarArchive.Open(streams, readerOptions); - - /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null - ) => (IAsyncArchive)Open(streams, readerOptions); + ) => TarArchive.OpenArchive(streams, readerOptions); /// - public IArchive Open(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null) => - TarArchive.Open(fileInfos, readerOptions); + public IAsyncArchive OpenAsyncArchive( + IReadOnlyList streams, + ReaderOptions? readerOptions = null + ) => (IAsyncArchive)OpenArchive(streams, readerOptions); /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( + IReadOnlyList fileInfos, + ReaderOptions? readerOptions = null + ) => TarArchive.OpenArchive(fileInfos, readerOptions); + + /// + public IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfos, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfos, readerOptions); } #endregion @@ -290,18 +294,18 @@ public class TarFactory #region IWriterFactory /// - public IWriter Open(Stream stream, WriterOptions writerOptions) => + public IWriter OpenWriter(Stream stream, WriterOptions writerOptions) => new TarWriter(stream, new TarWriterOptions(writerOptions)); /// - public IAsyncWriter OpenAsync( + public IAsyncWriter OpenAsyncWriter( Stream stream, WriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(stream, writerOptions); + return (IAsyncWriter)OpenWriter(stream, writerOptions); } #endregion @@ -309,7 +313,7 @@ public class TarFactory #region IWriteableArchiveFactory /// - public IWritableArchive CreateWriteableArchive() => TarArchive.Create(); + public IWritableArchive CreateArchive() => TarArchive.CreateArchive(); #endregion } diff --git a/src/SharpCompress/Factories/ZipFactory.cs b/src/SharpCompress/Factories/ZipFactory.cs index bdf8fedd..8487fa5d 100644 --- a/src/SharpCompress/Factories/ZipFactory.cs +++ b/src/SharpCompress/Factories/ZipFactory.cs @@ -139,26 +139,26 @@ public class ZipFactory #region IArchiveFactory /// - public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) => - ZipArchive.Open(stream, readerOptions); + public IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null) => + ZipArchive.OpenArchive(stream, readerOptions); /// - public IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null) => - (IAsyncArchive)Open(stream, readerOptions); + public IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null) => + (IAsyncArchive)OpenArchive(stream, readerOptions); /// - public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) => - ZipArchive.Open(fileInfo, readerOptions); + public IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null) => + ZipArchive.OpenArchive(fileInfo, readerOptions); /// - public IAsyncArchive OpenAsync( + public IAsyncArchive OpenAsyncArchive( FileInfo fileInfo, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfo, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfo, readerOptions); } #endregion @@ -166,28 +166,32 @@ public class ZipFactory #region IMultiArchiveFactory /// - public IArchive Open(IReadOnlyList streams, ReaderOptions? readerOptions = null) => - ZipArchive.Open(streams, readerOptions); - - /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( IReadOnlyList streams, ReaderOptions? readerOptions = null - ) => (IAsyncArchive)Open(streams, readerOptions); + ) => ZipArchive.OpenArchive(streams, readerOptions); /// - public IArchive Open(IReadOnlyList fileInfos, ReaderOptions? readerOptions = null) => - ZipArchive.Open(fileInfos, readerOptions); + public IAsyncArchive OpenAsyncArchive( + IReadOnlyList streams, + ReaderOptions? readerOptions = null + ) => (IAsyncArchive)OpenArchive(streams, readerOptions); /// - public IAsyncArchive OpenAsync( + public IArchive OpenArchive( + IReadOnlyList fileInfos, + ReaderOptions? readerOptions = null + ) => ZipArchive.OpenArchive(fileInfos, readerOptions); + + /// + public IAsyncArchive OpenAsyncArchive( IReadOnlyList fileInfos, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncArchive)Open(fileInfos, readerOptions); + return (IAsyncArchive)OpenArchive(fileInfos, readerOptions); } #endregion @@ -214,18 +218,18 @@ public class ZipFactory #region IWriterFactory /// - public IWriter Open(Stream stream, WriterOptions writerOptions) => + public IWriter OpenWriter(Stream stream, WriterOptions writerOptions) => new ZipWriter(stream, new ZipWriterOptions(writerOptions)); /// - public IAsyncWriter OpenAsync( + public IAsyncWriter OpenAsyncWriter( Stream stream, WriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(stream, writerOptions); + return (IAsyncWriter)OpenWriter(stream, writerOptions); } #endregion @@ -233,7 +237,7 @@ public class ZipFactory #region IWriteableArchiveFactory /// - public IWritableArchive CreateWriteableArchive() => ZipArchive.Create(); + public IWritableArchive CreateArchive() => ZipArchive.CreateArchive(); #endregion } diff --git a/src/SharpCompress/Readers/ReaderFactory.cs b/src/SharpCompress/Readers/ReaderFactory.cs index 7bf72fe9..e104e67d 100644 --- a/src/SharpCompress/Readers/ReaderFactory.cs +++ b/src/SharpCompress/Readers/ReaderFactory.cs @@ -11,10 +11,10 @@ namespace SharpCompress.Readers; public static class ReaderFactory { - public static IReader Open(string filePath, ReaderOptions? options = null) + public static IReader OpenReader(string filePath, ReaderOptions? options = null) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), options); + return OpenReader(new FileInfo(filePath), options); } /// @@ -24,20 +24,20 @@ public static class ReaderFactory /// /// /// - public static IAsyncReader OpenAsync( + public static IAsyncReader OpenAsyncReader( string filePath, ReaderOptions? options = null, CancellationToken cancellationToken = default ) { filePath.NotNullOrEmpty(nameof(filePath)); - return OpenAsync(new FileInfo(filePath), options, cancellationToken); + return OpenAsyncReader(new FileInfo(filePath), options, cancellationToken); } - public static IReader Open(FileInfo fileInfo, ReaderOptions? options = null) + public static IReader OpenReader(FileInfo fileInfo, ReaderOptions? options = null) { options ??= new ReaderOptions { LeaveStreamOpen = false }; - return Open(fileInfo.OpenRead(), options); + return OpenReader(fileInfo.OpenRead(), options); } /// @@ -47,14 +47,14 @@ public static class ReaderFactory /// /// /// - public static IAsyncReader OpenAsync( + public static IAsyncReader OpenAsyncReader( FileInfo fileInfo, ReaderOptions? options = null, CancellationToken cancellationToken = default ) { options ??= new ReaderOptions { LeaveStreamOpen = false }; - return OpenAsync(fileInfo.OpenRead(), options, cancellationToken); + return OpenAsyncReader(fileInfo.OpenRead(), options, cancellationToken); } /// @@ -63,7 +63,7 @@ public static class ReaderFactory /// /// /// - public static IReader Open(Stream stream, ReaderOptions? options = null) + public static IReader OpenReader(Stream stream, ReaderOptions? options = null) { stream.NotNull(nameof(stream)); options ??= new ReaderOptions() { LeaveStreamOpen = false }; @@ -110,7 +110,7 @@ public static class ReaderFactory ); } - public static IAsyncReader OpenAsync( + public static IAsyncReader OpenAsyncReader( Stream stream, ReaderOptions? options = null, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Writers/GZip/GZipWriter.Factory.cs b/src/SharpCompress/Writers/GZip/GZipWriter.Factory.cs index 57a22b54..7fd8aec1 100644 --- a/src/SharpCompress/Writers/GZip/GZipWriter.Factory.cs +++ b/src/SharpCompress/Writers/GZip/GZipWriter.Factory.cs @@ -7,52 +7,52 @@ namespace SharpCompress.Writers.GZip; public partial class GZipWriter : IWriterOpenable { - public static IWriter Open(string filePath, GZipWriterOptions writerOptions) + public static IWriter OpenWriter(string filePath, GZipWriterOptions writerOptions) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), writerOptions); + return OpenWriter(new FileInfo(filePath), writerOptions); } - public static IWriter Open(FileInfo fileInfo, GZipWriterOptions writerOptions) + public static IWriter OpenWriter(FileInfo fileInfo, GZipWriterOptions writerOptions) { fileInfo.NotNull(nameof(fileInfo)); return new GZipWriter(fileInfo.OpenWrite(), writerOptions); } - public static IWriter Open(Stream stream, GZipWriterOptions writerOptions) + public static IWriter OpenWriter(Stream stream, GZipWriterOptions writerOptions) { stream.NotNull(nameof(stream)); return new GZipWriter(stream, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( string path, GZipWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(path, writerOptions); + return (IAsyncWriter)OpenWriter(path, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( Stream stream, GZipWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(stream, writerOptions); + return (IAsyncWriter)OpenWriter(stream, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( FileInfo fileInfo, GZipWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(fileInfo, writerOptions); + return (IAsyncWriter)OpenWriter(fileInfo, writerOptions); } } #endif diff --git a/src/SharpCompress/Writers/IWriterFactory.cs b/src/SharpCompress/Writers/IWriterFactory.cs index 9615f078..f8bd8bde 100644 --- a/src/SharpCompress/Writers/IWriterFactory.cs +++ b/src/SharpCompress/Writers/IWriterFactory.cs @@ -6,9 +6,9 @@ namespace SharpCompress.Writers; public interface IWriterFactory : IFactory { - IWriter Open(Stream stream, WriterOptions writerOptions); + IWriter OpenWriter(Stream stream, WriterOptions writerOptions); - IAsyncWriter OpenAsync( + IAsyncWriter OpenAsyncWriter( Stream stream, WriterOptions writerOptions, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Writers/IWriterOpenable.cs b/src/SharpCompress/Writers/IWriterOpenable.cs index f856a309..14b98f71 100644 --- a/src/SharpCompress/Writers/IWriterOpenable.cs +++ b/src/SharpCompress/Writers/IWriterOpenable.cs @@ -7,10 +7,10 @@ namespace SharpCompress.Writers; public interface IWriterOpenable where TWriterOptions : WriterOptions { - public static abstract IWriter Open(string filePath, TWriterOptions writerOptions); + public static abstract IWriter OpenWriter(string filePath, TWriterOptions writerOptions); - public static abstract IWriter Open(FileInfo fileInfo, TWriterOptions writerOptions); - public static abstract IWriter Open(Stream stream, TWriterOptions writerOptions); + public static abstract IWriter OpenWriter(FileInfo fileInfo, TWriterOptions writerOptions); + public static abstract IWriter OpenWriter(Stream stream, TWriterOptions writerOptions); /// /// Opens a Writer asynchronously. @@ -20,19 +20,19 @@ public interface IWriterOpenable /// Writer options. /// Cancellation token. /// A task that returns an IWriter. - public static abstract IAsyncWriter OpenAsync( + public static abstract IAsyncWriter OpenAsyncWriter( Stream stream, TWriterOptions writerOptions, CancellationToken cancellationToken = default ); - public static abstract IAsyncWriter OpenAsync( + public static abstract IAsyncWriter OpenAsyncWriter( string filePath, TWriterOptions writerOptions, CancellationToken cancellationToken = default ); - public static abstract IAsyncWriter OpenAsync( + public static abstract IAsyncWriter OpenAsyncWriter( FileInfo fileInfo, TWriterOptions writerOptions, CancellationToken cancellationToken = default diff --git a/src/SharpCompress/Writers/Tar/TarWriter.Factory.cs b/src/SharpCompress/Writers/Tar/TarWriter.Factory.cs index 059fd62e..c5f9c846 100644 --- a/src/SharpCompress/Writers/Tar/TarWriter.Factory.cs +++ b/src/SharpCompress/Writers/Tar/TarWriter.Factory.cs @@ -7,52 +7,52 @@ namespace SharpCompress.Writers.Tar; public partial class TarWriter : IWriterOpenable { - public static IWriter Open(string filePath, TarWriterOptions writerOptions) + public static IWriter OpenWriter(string filePath, TarWriterOptions writerOptions) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), writerOptions); + return OpenWriter(new FileInfo(filePath), writerOptions); } - public static IWriter Open(FileInfo fileInfo, TarWriterOptions writerOptions) + public static IWriter OpenWriter(FileInfo fileInfo, TarWriterOptions writerOptions) { fileInfo.NotNull(nameof(fileInfo)); return new TarWriter(fileInfo.OpenWrite(), writerOptions); } - public static IWriter Open(Stream stream, TarWriterOptions writerOptions) + public static IWriter OpenWriter(Stream stream, TarWriterOptions writerOptions) { stream.NotNull(nameof(stream)); return new TarWriter(stream, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( string path, TarWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(path, writerOptions); + return (IAsyncWriter)OpenWriter(path, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( Stream stream, TarWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(stream, writerOptions); + return (IAsyncWriter)OpenWriter(stream, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( FileInfo fileInfo, TarWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(fileInfo, writerOptions); + return (IAsyncWriter)OpenWriter(fileInfo, writerOptions); } } #endif diff --git a/src/SharpCompress/Writers/WriterFactory.cs b/src/SharpCompress/Writers/WriterFactory.cs index 675ef675..0237e985 100644 --- a/src/SharpCompress/Writers/WriterFactory.cs +++ b/src/SharpCompress/Writers/WriterFactory.cs @@ -28,7 +28,7 @@ public static class WriterFactory return Open(fileInfo.OpenWrite(), archiveType, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( string filePath, ArchiveType archiveType, WriterOptions writerOptions, @@ -36,10 +36,10 @@ public static class WriterFactory ) { filePath.NotNullOrEmpty(nameof(filePath)); - return OpenAsync(new FileInfo(filePath), archiveType, writerOptions, cancellationToken); + return OpenAsyncWriter(new FileInfo(filePath), archiveType, writerOptions, cancellationToken); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( FileInfo fileInfo, ArchiveType archiveType, WriterOptions writerOptions, @@ -47,7 +47,7 @@ public static class WriterFactory ) { fileInfo.NotNull(nameof(fileInfo)); - return OpenAsync( + return OpenAsyncWriter( fileInfo.Open(FileMode.Create, FileAccess.Write), archiveType, writerOptions, @@ -63,7 +63,7 @@ public static class WriterFactory if (factory != null) { - return factory.Open(stream, writerOptions); + return factory.OpenWriter(stream, writerOptions); } throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType); @@ -77,7 +77,7 @@ public static class WriterFactory /// Writer options. /// Cancellation token. /// A task that returns an IWriter. - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( Stream stream, ArchiveType archiveType, WriterOptions writerOptions, @@ -90,7 +90,7 @@ public static class WriterFactory if (factory != null) { - return factory.OpenAsync(stream, writerOptions, cancellationToken); + return factory.OpenAsyncWriter(stream, writerOptions, cancellationToken); } throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType); diff --git a/src/SharpCompress/Writers/Zip/ZipWriter.Factory.cs b/src/SharpCompress/Writers/Zip/ZipWriter.Factory.cs index 44825a72..0df1a81c 100644 --- a/src/SharpCompress/Writers/Zip/ZipWriter.Factory.cs +++ b/src/SharpCompress/Writers/Zip/ZipWriter.Factory.cs @@ -7,52 +7,52 @@ namespace SharpCompress.Writers.Zip; public partial class ZipWriter : IWriterOpenable { - public static IWriter Open(string filePath, ZipWriterOptions writerOptions) + public static IWriter OpenWriter(string filePath, ZipWriterOptions writerOptions) { filePath.NotNullOrEmpty(nameof(filePath)); - return Open(new FileInfo(filePath), writerOptions); + return OpenWriter(new FileInfo(filePath), writerOptions); } - public static IWriter Open(FileInfo fileInfo, ZipWriterOptions writerOptions) + public static IWriter OpenWriter(FileInfo fileInfo, ZipWriterOptions writerOptions) { fileInfo.NotNull(nameof(fileInfo)); return new ZipWriter(fileInfo.OpenWrite(), writerOptions); } - public static IWriter Open(Stream stream, ZipWriterOptions writerOptions) + public static IWriter OpenWriter(Stream stream, ZipWriterOptions writerOptions) { stream.NotNull(nameof(stream)); return new ZipWriter(stream, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( string path, ZipWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(path, writerOptions); + return (IAsyncWriter)OpenWriter(path, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( Stream stream, ZipWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(stream, writerOptions); + return (IAsyncWriter)OpenWriter(stream, writerOptions); } - public static IAsyncWriter OpenAsync( + public static IAsyncWriter OpenAsyncWriter( FileInfo fileInfo, ZipWriterOptions writerOptions, CancellationToken cancellationToken = default ) { cancellationToken.ThrowIfCancellationRequested(); - return (IAsyncWriter)Open(fileInfo, writerOptions); + return (IAsyncWriter)OpenWriter(fileInfo, writerOptions); } } #endif diff --git a/tests/SharpCompress.Performance/Program.cs b/tests/SharpCompress.Performance/Program.cs index d445208a..c6d29ec6 100644 --- a/tests/SharpCompress.Performance/Program.cs +++ b/tests/SharpCompress.Performance/Program.cs @@ -30,14 +30,14 @@ using (var __ = JetbrainsProfiler.Cpu($"/Users/adam/temp/")) for (int i = 0; i < 50; i++) { - using var found = ArchiveFactory.Open(arcs[0]); + using var found = ArchiveFactory.OpenArchive(arcs[0]); foreach (var entry in found.Entries.Where(entry => !entry.IsDirectory)) { Console.WriteLine($"Extracting {entry.Key}"); using var entryStream = entry.OpenEntryStream(); entryStream.CopyTo(Stream.Null); } - /*using var found = ReaderFactory.Open(arcs[0]); + /*using var found = ReaderFactory.OpenReader(arcs[0]); while (found.MoveToNextEntry()) { var entry = found.Entry; diff --git a/tests/SharpCompress.Test/Ace/AceReaderTests.cs b/tests/SharpCompress.Test/Ace/AceReaderTests.cs index b6cf97f2..60c51c12 100644 --- a/tests/SharpCompress.Test/Ace/AceReaderTests.cs +++ b/tests/SharpCompress.Test/Ace/AceReaderTests.cs @@ -53,7 +53,7 @@ namespace SharpCompress.Test.Ace var exception = Assert.Throws(() => DoMultiReader( ["Ace.store.split.ace", "Ace.store.split.c01"], - streams => AceReader.Open(streams) + streams => AceReader.OpenReader(streams) ) ); } diff --git a/tests/SharpCompress.Test/ArchiveTests.cs b/tests/SharpCompress.Test/ArchiveTests.cs index 1fe1b024..e392f9d3 100644 --- a/tests/SharpCompress.Test/ArchiveTests.cs +++ b/tests/SharpCompress.Test/ArchiveTests.cs @@ -43,7 +43,7 @@ public class ArchiveTests : ReaderTests foreach (var path in testArchives) { using ( - var stream = SharpCompressStream.Create( + var stream = SharpCompressStream.CreateArchive( File.OpenRead(path), leaveOpen: true, throwOnDispose: true @@ -52,7 +52,7 @@ public class ArchiveTests : ReaderTests { try { - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); Assert.True(archive.IsSolid); using (var reader = archive.ExtractAllEntries()) { @@ -123,13 +123,13 @@ public class ArchiveTests : ReaderTests foreach (var path in testArchives) { using ( - var stream = SharpCompressStream.Create( + var stream = SharpCompressStream.CreateArchive( File.OpenRead(path), leaveOpen: true, throwOnDispose: true ) ) - using (var archive = archiveFactory.Open(stream, readerOptions)) + using (var archive = archiveFactory.OpenArchive(stream, readerOptions)) { try { @@ -168,7 +168,7 @@ public class ArchiveTests : ReaderTests ) { using ( - var archive = ArchiveFactory.Open( + var archive = ArchiveFactory.OpenArchive( testArchives.Select(a => new FileInfo(a)), readerOptions ) @@ -200,7 +200,7 @@ public class ArchiveTests : ReaderTests ) { using ( - var archive = ArchiveFactory.Open( + var archive = ArchiveFactory.OpenArchive( testArchives.Select(f => new FileInfo(f)), readerOptions ) @@ -235,7 +235,10 @@ public class ArchiveTests : ReaderTests ) { var src = testArchives.ToArray(); - using var archive = ArchiveFactory.Open(src.Select(f => new FileInfo(f)), readerOptions); + using var archive = ArchiveFactory.OpenArchive( + src.Select(f => new FileInfo(f)), + readerOptions + ); var idx = 0; foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -260,7 +263,7 @@ public class ArchiveTests : ReaderTests ) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using (var archive = ArchiveFactory.Open(new FileInfo(testArchive), readerOptions)) + using (var archive = ArchiveFactory.OpenArchive(new FileInfo(testArchive), readerOptions)) { archive.WriteToDirectory(SCRATCH_FILES_PATH); } @@ -274,7 +277,7 @@ public class ArchiveTests : ReaderTests ) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using (var archive = archiveFactory.Open(new FileInfo(testArchive), readerOptions)) + using (var archive = archiveFactory.OpenArchive(new FileInfo(testArchive), readerOptions)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -302,7 +305,7 @@ public class ArchiveTests : ReaderTests } var expected = new Stack(fileOrder.Split(' ')); testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using var archive = ArchiveFactory.Open(testArchive, readerOptions); + using var archive = ArchiveFactory.OpenArchive(testArchive, readerOptions); foreach (var entry in archive.Entries) { Assert.Equal(expected.Pop(), entry.Key); @@ -315,7 +318,7 @@ public class ArchiveTests : ReaderTests protected void ArchiveFileReadEx(string testArchive) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using (var archive = ArchiveFactory.Open(testArchive)) + using (var archive = ArchiveFactory.OpenArchive(testArchive)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -337,7 +340,7 @@ public class ArchiveTests : ReaderTests protected void ArchiveDeltaDistanceRead(string testArchive) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using var archive = ArchiveFactory.Open(testArchive); + using var archive = ArchiveFactory.OpenArchive(testArchive); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -377,7 +380,7 @@ public class ArchiveTests : ReaderTests { writerOptions.CompressionLevel = compressionLevel.Value; } - return WriterFactory.Open(stream, ArchiveType.Zip, writerOptions); + return WriterFactory.OpenArchive(stream, ArchiveType.Zip, writerOptions); } protected static IAsyncWriter CreateWriterWithLevelAsync( @@ -391,7 +394,11 @@ public class ArchiveTests : ReaderTests { writerOptions.CompressionLevel = compressionLevel.Value; } - return WriterFactory.OpenAsync(new AsyncOnlyStream(stream), ArchiveType.Zip, writerOptions); + return WriterFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream), + ArchiveType.Zip, + writerOptions + ); } /// @@ -403,7 +410,7 @@ public class ArchiveTests : ReaderTests ) { zipStream.Position = 0; - using var archive = ArchiveFactory.Open(zipStream); + using var archive = ArchiveFactory.OpenArchive(zipStream); Assert.Equal(expectedFiles.Count, archive.Entries.Count()); foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) @@ -554,7 +561,7 @@ public class ArchiveTests : ReaderTests ) { zipStream.Position = 0; - using var archive = ArchiveFactory.Open(zipStream); + using var archive = ArchiveFactory.OpenArchive(zipStream); foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) { @@ -571,7 +578,7 @@ public class ArchiveTests : ReaderTests ) { zipStream.Position = 0; - using var archive = ArchiveFactory.Open(zipStream); + using var archive = ArchiveFactory.OpenArchive(zipStream); var entry = archive.Entries.FirstOrDefault(e => e.Key == entryName && !e.IsDirectory); Assert.NotNull(entry); @@ -608,14 +615,17 @@ public class ArchiveTests : ReaderTests foreach (var path in testArchives) { using ( - var stream = SharpCompressStream.Create( + var stream = SharpCompressStream.CreateArchive( File.OpenRead(path), leaveOpen: true, throwOnDispose: true ) ) await using ( - var archive = archiveFactory.OpenAsync(new AsyncOnlyStream(stream), readerOptions) + var archive = archiveFactory.OpenAsyncArchive( + new AsyncOnlyStream(stream), + readerOptions + ) ) { try @@ -651,9 +661,9 @@ public class ArchiveTests : ReaderTests // Open with a pre-wrapped stream using (var fileStream = File.OpenRead(testArchive)) - using (var wrappedStream = SharpCompressStream.Create(fileStream, bufferSize: 32768)) + using (var wrappedStream = SharpCompressStream.CreateArchive(fileStream, bufferSize: 32768)) await using ( - var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(wrappedStream)) + var archive = await ArchiveFactory.OpenAsyncArchive(new AsyncOnlyStream(wrappedStream)) ) { Assert.Equal(ArchiveType.Zip, archive.Type); @@ -669,7 +679,9 @@ public class ArchiveTests : ReaderTests var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.noEmptyDirs.zip"); 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.Equal(ArchiveType.Zip, archive.Type); Assert.Equal(3, await archive.EntriesAsync.CountAsync()); diff --git a/tests/SharpCompress.Test/Arj/ArjReaderTests.cs b/tests/SharpCompress.Test/Arj/ArjReaderTests.cs index bad98ec8..054c18f6 100644 --- a/tests/SharpCompress.Test/Arj/ArjReaderTests.cs +++ b/tests/SharpCompress.Test/Arj/ArjReaderTests.cs @@ -54,7 +54,7 @@ namespace SharpCompress.Test.Arj "Arj.store.split.a04", "Arj.store.split.a05", ], - streams => ArjReader.Open(streams) + streams => ArjReader.OpenReader(streams) ) ); } diff --git a/tests/SharpCompress.Test/BZip2/BZip2ReaderTests.cs b/tests/SharpCompress.Test/BZip2/BZip2ReaderTests.cs index e0fa0583..620f307c 100644 --- a/tests/SharpCompress.Test/BZip2/BZip2ReaderTests.cs +++ b/tests/SharpCompress.Test/BZip2/BZip2ReaderTests.cs @@ -16,6 +16,6 @@ public class BZip2ReaderTests : ReaderTests Stream stream = new MemoryStream( new byte[] { 0x42, 0x5a, 0x68, 0x34, 0x31, 0x41, 0x59, 0x26, 0x53, 0x59, 0x35 } ); - Assert.Throws(typeof(InvalidOperationException), () => ReaderFactory.Open(stream)); + Assert.Throws(typeof(InvalidOperationException), () => ReaderFactory.OpenReader(stream)); } } diff --git a/tests/SharpCompress.Test/ExtractAll.cs b/tests/SharpCompress.Test/ExtractAll.cs index d2643fcd..1e047bc0 100644 --- a/tests/SharpCompress.Test/ExtractAll.cs +++ b/tests/SharpCompress.Test/ExtractAll.cs @@ -23,7 +23,7 @@ public class ExtractAllTests : TestBase var testArchive = Path.Combine(TEST_ARCHIVES_PATH, archivePath); var options = new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }; - await using var archive = await ArchiveFactory.OpenAsync(testArchive); + await using var archive = await ArchiveFactory.OpenAsyncArchive(testArchive); await archive.WriteToDirectoryAsync(SCRATCH_FILES_PATH, options); } @@ -40,7 +40,7 @@ public class ExtractAllTests : TestBase var testArchive = Path.Combine(TEST_ARCHIVES_PATH, archivePath); var options = new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }; - using var archive = ArchiveFactory.Open(testArchive); + using var archive = ArchiveFactory.OpenArchive(testArchive); archive.WriteToDirectory(SCRATCH_FILES_PATH, options); } } diff --git a/tests/SharpCompress.Test/ExtractAllEntriesTests.cs b/tests/SharpCompress.Test/ExtractAllEntriesTests.cs index 007f620f..57bbcc50 100644 --- a/tests/SharpCompress.Test/ExtractAllEntriesTests.cs +++ b/tests/SharpCompress.Test/ExtractAllEntriesTests.cs @@ -18,7 +18,7 @@ public class ExtractAllEntriesTests : TestBase { var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"); - using var archive = ArchiveFactory.Open(archivePath); + using var archive = ArchiveFactory.OpenArchive(archivePath); Assert.Throws(() => { using var reader = archive.ExtractAllEntries(); @@ -30,7 +30,7 @@ public class ExtractAllEntriesTests : TestBase { var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "Rar.solid.rar"); - using var archive = ArchiveFactory.Open(archivePath); + using var archive = ArchiveFactory.OpenArchive(archivePath); Assert.True(archive.IsSolid); // Calculate total size like user code does diff --git a/tests/SharpCompress.Test/ExtractionTests.cs b/tests/SharpCompress.Test/ExtractionTests.cs index 04b5b08f..2edb8110 100644 --- a/tests/SharpCompress.Test/ExtractionTests.cs +++ b/tests/SharpCompress.Test/ExtractionTests.cs @@ -27,7 +27,7 @@ public class ExtractionTests : TestBase using (var stream = File.Create(testArchive)) { using var writer = (ZipWriter) - WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate); + WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate); // Create a test file to add to the archive var testFilePath = Path.Combine(SCRATCH2_FILES_PATH, "testfile.txt"); @@ -39,7 +39,7 @@ public class ExtractionTests : TestBase // Extract the archive - this should succeed regardless of path casing using (var stream = File.OpenRead(testArchive)) { - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); // This should not throw an exception even if Path.GetFullPath returns // a path with different casing than the actual directory @@ -72,7 +72,7 @@ public class ExtractionTests : TestBase using (var stream = File.Create(testArchive)) { using var writer = (ZipWriter) - WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate); + WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate); var testFilePath = Path.Combine(SCRATCH2_FILES_PATH, "testfile2.txt"); File.WriteAllText(testFilePath, "Test content"); @@ -84,7 +84,7 @@ public class ExtractionTests : TestBase // Extract the archive - this should throw an exception for path traversal using (var stream = File.OpenRead(testArchive)) { - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); var exception = Assert.Throws(() => reader.WriteAllToDirectory( diff --git a/tests/SharpCompress.Test/GZip/AsyncTests.cs b/tests/SharpCompress.Test/GZip/AsyncTests.cs index 5d1a7fb2..a35b295f 100644 --- a/tests/SharpCompress.Test/GZip/AsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/AsyncTests.cs @@ -26,7 +26,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncArchive(new AsyncOnlyStream(stream)); await reader.WriteAllToDirectoryAsync( SCRATCH_FILES_PATH, @@ -51,7 +51,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncArchive(new AsyncOnlyStream(stream)); while (await reader.MoveToNextEntryAsync()) { @@ -74,7 +74,7 @@ public class AsyncTests : TestBase public async ValueTask Archive_Entry_Async_Open_Stream() { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"); - await using var archive = await ArchiveFactory.OpenAsync( + await using var archive = await ArchiveFactory.OpenAsyncArchive( new AsyncOnlyStream(File.OpenRead(testArchive)) ); @@ -106,7 +106,7 @@ public class AsyncTests : TestBase await using (var stream = File.Create(outputPath)) #endif using ( - var writer = WriterFactory.OpenAsync( + var writer = WriterFactory.OpenAsyncArchive( new AsyncOnlyStream(stream), ArchiveType.Zip, CompressionType.Deflate @@ -125,7 +125,7 @@ public class AsyncTests : TestBase // Verify the archive was created and contains the entry Assert.True(File.Exists(outputPath)); - await using var archive = ZipArchive.OpenAsync(outputPath); + await using var archive = ZipArchive.OpenAsyncArchive(outputPath); Assert.Single(await archive.EntriesAsync.Where(e => !e.IsDirectory).ToListAsync()); } @@ -141,7 +141,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncArchive( new AsyncOnlyStream(stream), cancellationToken: cts.Token ); @@ -195,7 +195,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncArchive(new AsyncOnlyStream(stream)); while (await reader.MoveToNextEntryAsync()) { diff --git a/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs index 98bcf41a..7ebf2425 100644 --- a/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs @@ -22,7 +22,7 @@ public class GZipArchiveAsyncTests : ArchiveTests #else await using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) #endif - using (var archive = ArchiveFactory.Open(new AsyncOnlyStream(stream))) + using (var archive = ArchiveFactory.OpenArchive(new AsyncOnlyStream(stream))) { var entry = archive.Entries.First(); await entry.WriteToFileAsync(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); @@ -49,7 +49,7 @@ public class GZipArchiveAsyncTests : ArchiveTests await using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) #endif { - await using (var archive = GZipArchive.OpenAsync(new AsyncOnlyStream(stream))) + await using (var archive = GZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream))) { var entry = await archive.EntriesAsync.FirstAsync(); await entry.WriteToFileAsync(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); @@ -77,7 +77,7 @@ public class GZipArchiveAsyncTests : ArchiveTests #else await using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); #endif - await using (var archive = GZipArchive.OpenAsync(new AsyncOnlyStream(stream))) + await using (var archive = GZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream))) { Assert.Throws(() => archive.AddEntry("jpg\\test.jpg", jpg)); await archive.SaveToAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")); @@ -98,7 +98,7 @@ public class GZipArchiveAsyncTests : ArchiveTests inputStream.Position = 0; } - using var archive = GZipArchive.Open(new AsyncOnlyStream(inputStream)); + using var archive = GZipArchive.OpenArchive(new AsyncOnlyStream(inputStream)); var archiveEntry = archive.Entries.First(); MemoryStream tarStream; @@ -148,7 +148,7 @@ public class GZipArchiveAsyncTests : ArchiveTests public async Task TestGzCrcWithMostSignificantBitNotNegative_Async() { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - await using var archive = GZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = GZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream)); await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) { Assert.InRange(entry.Crc, 0L, 0xFFFFFFFFL); @@ -159,7 +159,7 @@ public class GZipArchiveAsyncTests : ArchiveTests public async Task TestGzArchiveTypeGzip_Async() { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - await using var archive = GZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + await using var archive = GZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream)); Assert.Equal(archive.Type, ArchiveType.GZip); } } diff --git a/tests/SharpCompress.Test/GZip/GZipArchiveDirectoryTests.cs b/tests/SharpCompress.Test/GZip/GZipArchiveDirectoryTests.cs index 201effcb..d1d7fbf1 100644 --- a/tests/SharpCompress.Test/GZip/GZipArchiveDirectoryTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipArchiveDirectoryTests.cs @@ -10,7 +10,7 @@ public class GZipArchiveDirectoryTests : TestBase [Fact] public void GZipArchive_AddDirectoryEntry_ThrowsNotSupportedException() { - using var archive = GZipArchive.Create(); + using var archive = GZipArchive.CreateArchive(); Assert.Throws(() => archive.AddDirectoryEntry("test-dir", DateTime.Now) diff --git a/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs b/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs index c8a87327..448406a2 100644 --- a/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipArchiveTests.cs @@ -17,7 +17,7 @@ public class GZipArchiveTests : ArchiveTests public void 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 = ArchiveFactory.OpenArchive(stream)) { var entry = archive.Entries.First(); entry.WriteToFile(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); @@ -39,7 +39,7 @@ public class GZipArchiveTests : ArchiveTests public void GZip_Archive() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) - using (var archive = GZipArchive.Open(stream)) + using (var archive = GZipArchive.OpenArchive(stream)) { var entry = archive.Entries.First(); entry.WriteToFile(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); @@ -62,7 +62,7 @@ public class GZipArchiveTests : ArchiveTests { var jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg"); using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - using var archive = GZipArchive.Open(stream); + using var archive = GZipArchive.OpenArchive(stream); Assert.Throws(() => archive.AddEntry("jpg\\test.jpg", jpg)); archive.SaveTo(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")); } @@ -76,7 +76,7 @@ public class GZipArchiveTests : ArchiveTests fileStream.CopyTo(inputStream); inputStream.Position = 0; } - using var archive = GZipArchive.Open(inputStream); + using var archive = GZipArchive.OpenArchive(inputStream); var archiveEntry = archive.Entries.First(); MemoryStream tarStream; @@ -110,7 +110,7 @@ public class GZipArchiveTests : ArchiveTests public void TestGzCrcWithMostSignificantBitNotNegative() { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - using var archive = GZipArchive.Open(stream); + using var archive = GZipArchive.OpenArchive(stream); //process all entries in solid archive until the one we want to test foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -122,7 +122,7 @@ public class GZipArchiveTests : ArchiveTests public void TestGzArchiveTypeGzip() { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - using var archive = GZipArchive.Open(stream); + using var archive = GZipArchive.OpenArchive(stream); Assert.Equal(archive.Type, ArchiveType.GZip); } @@ -137,7 +137,7 @@ public class GZipArchiveTests : ArchiveTests // Create a non-seekable wrapper around the MemoryStream using var nonSeekableStream = new NonSeekableStream(buffer); - using var reader = SharpCompress.Readers.GZip.GZipReader.Open(nonSeekableStream); + using var reader = SharpCompress.Readers.GZip.GZipReader.OpenReader(nonSeekableStream); // Verify we can move to the first entry and read it without exceptions Assert.True(reader.MoveToNextEntry()); diff --git a/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs b/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs index 58f5d9dc..8f47f8ab 100644 --- a/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs @@ -22,7 +22,7 @@ public class GZipReaderAsyncTests : ReaderTests { //read only as GZip item using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncArchive(new AsyncOnlyStream(stream)); while (await reader.MoveToNextEntryAsync()) { Assert.NotEqual(0, reader.Entry.Size); @@ -70,7 +70,7 @@ public class GZipReaderAsyncTests : ReaderTests bufferSize: options.BufferSize ); using var testStream = new TestStream(protectedStream); - await using (var reader = ReaderFactory.OpenAsync(testStream, options, default)) + await using (var reader = ReaderFactory.OpenAsyncArchive(testStream, options, default)) { await UseReaderAsync(reader, expectedCompression); protectedStream.ThrowOnDispose = false; diff --git a/tests/SharpCompress.Test/GZip/GZipReaderTests.cs b/tests/SharpCompress.Test/GZip/GZipReaderTests.cs index 187cd80c..c382a471 100644 --- a/tests/SharpCompress.Test/GZip/GZipReaderTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipReaderTests.cs @@ -18,7 +18,7 @@ public class GZipReaderTests : ReaderTests { //read only as GZip itme using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - using var reader = GZipReader.Open(new SharpCompressStream(stream)); + using var reader = GZipReader.OpenReader(new SharpCompressStream(stream)); while (reader.MoveToNextEntry()) // Crash here { Assert.NotEqual(0, reader.Entry.Size); diff --git a/tests/SharpCompress.Test/GZip/GZipWriterAsyncTests.cs b/tests/SharpCompress.Test/GZip/GZipWriterAsyncTests.cs index c93a14c9..80a59a59 100644 --- a/tests/SharpCompress.Test/GZip/GZipWriterAsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipWriterAsyncTests.cs @@ -24,7 +24,7 @@ public class GZipWriterAsyncTests : WriterTests ) ) using ( - var writer = WriterFactory.OpenAsync( + var writer = WriterFactory.OpenAsyncArchive( new AsyncOnlyStream(stream), ArchiveType.GZip, CompressionType.GZip @@ -64,7 +64,7 @@ public class GZipWriterAsyncTests : WriterTests Assert.Throws(() => { using Stream stream = File.OpenWrite(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")); - using var writer = WriterFactory.Open( + using var writer = WriterFactory.OpenWriter( new AsyncOnlyStream(stream), ArchiveType.GZip, CompressionType.BZip2 diff --git a/tests/SharpCompress.Test/GZip/GZipWriterTests.cs b/tests/SharpCompress.Test/GZip/GZipWriterTests.cs index f4ca13d3..c8d9deef 100644 --- a/tests/SharpCompress.Test/GZip/GZipWriterTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipWriterTests.cs @@ -21,7 +21,7 @@ public class GZipWriterTests : WriterTests FileAccess.Write ) ) - using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.GZip)) + using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.GZip, CompressionType.GZip)) { writer.Write("Tar.tar", Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); } @@ -56,7 +56,7 @@ public class GZipWriterTests : WriterTests Assert.Throws(() => { using Stream stream = File.OpenWrite(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")); - using var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.BZip2); + using var writer = WriterFactory.OpenWriter(stream, ArchiveType.GZip, CompressionType.BZip2); }); [Fact] diff --git a/tests/SharpCompress.Test/ProgressReportTests.cs b/tests/SharpCompress.Test/ProgressReportTests.cs index f2c7121e..a9308197 100644 --- a/tests/SharpCompress.Test/ProgressReportTests.cs +++ b/tests/SharpCompress.Test/ProgressReportTests.cs @@ -110,7 +110,7 @@ public class ProgressReportTests : TestBase archiveStream.Position = 0; var readerOptions = new ReaderOptions { Progress = progress }; - using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + using (var reader = ReaderFactory.OpenReader(archiveStream, readerOptions)) { while (reader.MoveToNextEntry()) { @@ -148,7 +148,7 @@ public class ProgressReportTests : TestBase // Now open as archive and extract entry with progress as parameter archiveStream.Position = 0; - using var archive = ZipArchive.Open(archiveStream); + using var archive = ZipArchive.OpenArchive(archiveStream); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -184,7 +184,7 @@ public class ProgressReportTests : TestBase // Now open as archive and extract entry async with progress as parameter archiveStream.Position = 0; - using var archive = ZipArchive.Open(archiveStream); + using var archive = ZipArchive.OpenArchive(archiveStream); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -237,7 +237,7 @@ public class ProgressReportTests : TestBase var readerOptions = new ReaderOptions(); Assert.Null(readerOptions.Progress); - using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + using (var reader = ReaderFactory.OpenReader(archiveStream, readerOptions)) { while (reader.MoveToNextEntry()) { @@ -267,7 +267,7 @@ public class ProgressReportTests : TestBase // Open archive and extract without progress archiveStream.Position = 0; - using var archive = ZipArchive.Open(archiveStream); + using var archive = ZipArchive.OpenArchive(archiveStream); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -326,7 +326,7 @@ public class ProgressReportTests : TestBase archiveStream.Position = 0; var readerOptions = new ReaderOptions { Progress = progress }; - using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + using (var reader = ReaderFactory.OpenReader(archiveStream, readerOptions)) { while (reader.MoveToNextEntry()) { @@ -367,7 +367,7 @@ public class ProgressReportTests : TestBase // Now open as archive and extract entry with progress as parameter archiveStream.Position = 0; - using var archive = SharpCompress.Archives.Tar.TarArchive.Open(archiveStream); + using var archive = SharpCompress.Archives.Tar.TarArchive.OpenArchive(archiveStream); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -406,7 +406,7 @@ public class ProgressReportTests : TestBase // Now open as archive and extract entry async with progress as parameter archiveStream.Position = 0; - using var archive = SharpCompress.Archives.Tar.TarArchive.Open(archiveStream); + using var archive = SharpCompress.Archives.Tar.TarArchive.OpenArchive(archiveStream); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -447,7 +447,7 @@ public class ProgressReportTests : TestBase archiveStream.Position = 0; var readerOptions = new ReaderOptions { Progress = progress }; - using (var reader = ReaderFactory.Open(archiveStream, readerOptions)) + using (var reader = ReaderFactory.OpenReader(archiveStream, readerOptions)) { while (reader.MoveToNextEntry()) { @@ -496,7 +496,7 @@ public class ProgressReportTests : TestBase // Now open as archive and extract entries with progress as parameter archiveStream.Position = 0; - using var archive = ZipArchive.Open(archiveStream); + using var archive = ZipArchive.OpenArchive(archiveStream); foreach (var entry in archive.Entries) { if (!entry.IsDirectory) @@ -541,7 +541,7 @@ public class ProgressReportTests : TestBase var readerOptions = new ReaderOptions { Progress = progress }; await using ( - var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(archiveStream), readerOptions) + var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(archiveStream), readerOptions) ) { while (await reader.MoveToNextEntryAsync()) diff --git a/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs b/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs index acfe4c27..c7cb76c4 100644 --- a/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs @@ -68,7 +68,7 @@ public class RarArchiveAsyncTests : ArchiveTests { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive))) using ( - var archive = RarArchive.Open( + var archive = RarArchive.OpenArchive( stream, new ReaderOptions { Password = password, LeaveStreamOpen = true } ) @@ -98,7 +98,7 @@ public class RarArchiveAsyncTests : ArchiveTests protected async Task ArchiveFileReadPasswordAsync(string archiveName, string password) { using ( - var archive = RarArchive.Open( + var archive = RarArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, archiveName), new ReaderOptions { Password = password, LeaveStreamOpen = true } ) @@ -137,7 +137,7 @@ public class RarArchiveAsyncTests : ArchiveTests private async ValueTask DoRar_test_invalid_exttime_ArchiveStreamReadAsync(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { await entry.WriteToDirectoryAsync( @@ -151,7 +151,7 @@ public class RarArchiveAsyncTests : ArchiveTests public async ValueTask Rar_Jpg_ArchiveStreamRead_Async() { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg")); - using (var archive = RarArchive.Open(stream, new ReaderOptions { LookForHeader = true })) + using (var archive = RarArchive.OpenArchive(stream, new ReaderOptions { LookForHeader = true })) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -176,7 +176,7 @@ public class RarArchiveAsyncTests : ArchiveTests { using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename))) { - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); Assert.False(archive.IsSolid); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -196,7 +196,7 @@ public class RarArchiveAsyncTests : ArchiveTests private async ValueTask DoRar_IsSolidEntryStreamCheckAsync(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); Assert.True(archive.IsSolid); IArchiveEntry[] entries = archive.Entries.Where(a => !a.IsDirectory).ToArray(); Assert.NotInRange(entries.Length, 0, 1); @@ -264,7 +264,7 @@ public class RarArchiveAsyncTests : ArchiveTests private async ValueTask DoRar_Multi_ArchiveStreamReadAsync(string[] archives, bool isSolid) { - using var archive = RarArchive.Open( + using var archive = RarArchive.OpenArchive( archives.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).Select(File.OpenRead) ); Assert.Equal(archive.IsSolid, isSolid); @@ -316,7 +316,7 @@ public class RarArchiveAsyncTests : ArchiveTests private Task DoRar_ArchiveFileRead_HasDirectoriesAsync(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); Assert.False(archive.IsSolid); Assert.Contains(true, archive.Entries.Select(entry => entry.IsDirectory)); return Task.CompletedTask; @@ -326,7 +326,7 @@ public class RarArchiveAsyncTests : ArchiveTests public async ValueTask Rar_Jpg_ArchiveFileRead_Async() { using ( - var archive = RarArchive.Open( + var archive = RarArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg"), new ReaderOptions { LookForHeader = true } ) @@ -386,7 +386,7 @@ public class RarArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar15.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(1, archive.MinVersion); Assert.Equal(1, archive.MaxVersion); } @@ -396,7 +396,7 @@ public class RarArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar2.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(2, archive.MinVersion); Assert.Equal(2, archive.MaxVersion); } @@ -406,7 +406,7 @@ public class RarArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar4.multi.part01.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(3, archive.MinVersion); Assert.Equal(4, archive.MaxVersion); } @@ -416,7 +416,7 @@ public class RarArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar5.solid.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(5, archive.MinVersion); Assert.Equal(6, archive.MaxVersion); } @@ -573,7 +573,7 @@ public class RarArchiveAsyncTests : ArchiveTests private void DoRar_IsFirstVolume_True(string firstFilename) { - using var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, firstFilename)); + using var archive = RarArchive.OpenArchive(Path.Combine(TEST_ARCHIVES_PATH, firstFilename)); Assert.True(archive.IsMultipartVolume()); Assert.True(archive.IsFirstVolume()); } @@ -588,7 +588,7 @@ public class RarArchiveAsyncTests : ArchiveTests private void DoRar_IsFirstVolume_False(string notFirstFilename) { - using var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, notFirstFilename)); + using var archive = RarArchive.OpenArchive(Path.Combine(TEST_ARCHIVES_PATH, notFirstFilename)); Assert.True(archive.IsMultipartVolume()); Assert.False(archive.IsFirstVolume()); } @@ -631,7 +631,7 @@ public class RarArchiveAsyncTests : ArchiveTests { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using var stream = File.OpenRead(testArchive); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { await entry.WriteToDirectoryAsync( @@ -649,7 +649,7 @@ public class RarArchiveAsyncTests : ArchiveTests { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using var stream = File.OpenRead(testArchive); - await using var archive = await ArchiveFactory.OpenAsync(stream); + await using var archive = await ArchiveFactory.OpenAsyncArchive(stream); Assert.True(await archive.IsSolidAsync()); await using (var reader = await archive.ExtractAllEntriesAsync()) { @@ -680,7 +680,7 @@ public class RarArchiveAsyncTests : ArchiveTests private async ValueTask ArchiveFileReadAsync(string testArchive) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); - using var archive = ArchiveFactory.Open(testArchive); + using var archive = ArchiveFactory.OpenArchive(testArchive); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { await entry.WriteToDirectoryAsync( @@ -697,7 +697,7 @@ public class RarArchiveAsyncTests : ArchiveTests ) { var paths = testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)); - using var archive = ArchiveFactory.Open(paths.Select(a => new FileInfo(a)), readerOptions); + using var archive = ArchiveFactory.OpenArchive(paths.Select(a => new FileInfo(a)), readerOptions); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { await entry.WriteToDirectoryAsync( @@ -714,7 +714,7 @@ public class RarArchiveAsyncTests : ArchiveTests ) { var paths = testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)); - using var archive = ArchiveFactory.Open(paths.Select(f => new FileInfo(f)), readerOptions); + using var archive = ArchiveFactory.OpenArchive(paths.Select(f => new FileInfo(f)), readerOptions); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { await entry.WriteToDirectoryAsync( diff --git a/tests/SharpCompress.Test/Rar/RarArchiveTests.cs b/tests/SharpCompress.Test/Rar/RarArchiveTests.cs index ba42f649..2117153d 100644 --- a/tests/SharpCompress.Test/Rar/RarArchiveTests.cs +++ b/tests/SharpCompress.Test/Rar/RarArchiveTests.cs @@ -68,7 +68,7 @@ public class RarArchiveTests : ArchiveTests { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive))) using ( - var archive = RarArchive.Open( + var archive = RarArchive.OpenArchive( stream, new ReaderOptions { Password = password, LeaveStreamOpen = true } ) @@ -98,7 +98,7 @@ public class RarArchiveTests : ArchiveTests protected void ArchiveFileReadPassword(string archiveName, string password) { using ( - var archive = RarArchive.Open( + var archive = RarArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, archiveName), new ReaderOptions { Password = password, LeaveStreamOpen = true } ) @@ -134,7 +134,7 @@ public class RarArchiveTests : ArchiveTests private void DoRar_test_invalid_exttime_ArchiveStreamRead(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { entry.WriteToDirectory( @@ -148,7 +148,7 @@ public class RarArchiveTests : ArchiveTests public void Rar_Jpg_ArchiveStreamRead() { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg")); - using (var archive = RarArchive.Open(stream, new ReaderOptions { LookForHeader = true })) + using (var archive = RarArchive.OpenArchive(stream, new ReaderOptions { LookForHeader = true })) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -171,7 +171,7 @@ public class RarArchiveTests : ArchiveTests { using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename))) { - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); Assert.False(archive.IsSolid); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -191,7 +191,7 @@ public class RarArchiveTests : ArchiveTests private void DoRar_IsSolidEntryStreamCheck(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); Assert.True(archive.IsSolid); IArchiveEntry[] entries = archive.Entries.Where(a => !a.IsDirectory).ToArray(); Assert.NotInRange(entries.Length, 0, 1); @@ -258,7 +258,7 @@ public class RarArchiveTests : ArchiveTests private void DoRar_Multi_ArchiveStreamRead(string[] archives, bool isSolid) { - using var archive = RarArchive.Open( + using var archive = RarArchive.OpenArchive( archives.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).Select(File.OpenRead) ); Assert.Equal(archive.IsSolid, isSolid); @@ -308,7 +308,7 @@ public class RarArchiveTests : ArchiveTests private void DoRar_ArchiveFileRead_HasDirectories(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); Assert.False(archive.IsSolid); Assert.Contains(true, archive.Entries.Select(entry => entry.IsDirectory)); } @@ -317,7 +317,7 @@ public class RarArchiveTests : ArchiveTests public void Rar_Jpg_ArchiveFileRead() { using ( - var archive = RarArchive.Open( + var archive = RarArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg"), new ReaderOptions { LookForHeader = true } ) @@ -374,7 +374,7 @@ public class RarArchiveTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar15.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(1, archive.MinVersion); Assert.Equal(1, archive.MaxVersion); } @@ -384,7 +384,7 @@ public class RarArchiveTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar2.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(2, archive.MinVersion); Assert.Equal(2, archive.MaxVersion); } @@ -394,7 +394,7 @@ public class RarArchiveTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar4.multi.part01.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(3, archive.MinVersion); Assert.Equal(4, archive.MaxVersion); } @@ -404,7 +404,7 @@ public class RarArchiveTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Rar5.solid.rar"); - using var archive = RarArchive.Open(testArchive); + using var archive = RarArchive.OpenArchive(testArchive); Assert.Equal(5, archive.MinVersion); Assert.Equal(6, archive.MaxVersion); } @@ -585,7 +585,7 @@ public class RarArchiveTests : ArchiveTests private void DoRar_IsFirstVolume_True(string firstFilename) { - using var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, firstFilename)); + using var archive = RarArchive.OpenArchive(Path.Combine(TEST_ARCHIVES_PATH, firstFilename)); Assert.True(archive.IsMultipartVolume()); Assert.True(archive.IsFirstVolume()); } @@ -598,7 +598,7 @@ public class RarArchiveTests : ArchiveTests private void DoRar_IsFirstVolume_False(string notFirstFilename) { - using var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, notFirstFilename)); + using var archive = RarArchive.OpenArchive(Path.Combine(TEST_ARCHIVES_PATH, notFirstFilename)); Assert.True(archive.IsMultipartVolume()); Assert.False(archive.IsFirstVolume()); } @@ -639,7 +639,7 @@ public class RarArchiveTests : ArchiveTests [Fact] public void Rar_TestEncryptedDetection() { - using var passwordProtectedFilesArchive = RarArchive.Open( + using var passwordProtectedFilesArchive = RarArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Rar.encrypted_filesOnly.rar") ); Assert.True(passwordProtectedFilesArchive.IsEncrypted); @@ -662,7 +662,7 @@ public class RarArchiveTests : ArchiveTests foreach (var testFile in testFiles) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testFile)); - using var archive = RarArchive.Open(stream); + using var archive = RarArchive.OpenArchive(stream); // Extract all entries and read them completely foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) @@ -704,7 +704,7 @@ public class RarArchiveTests : ArchiveTests // when we try to read beyond the truncated data var exception = Assert.Throws(() => { - using var archive = RarArchive.Open(truncatedStream); + using var archive = RarArchive.OpenArchive(truncatedStream); foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) { using var entryStream = entry.OpenEntryStream(); diff --git a/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs b/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs index d58c2a93..f32e0886 100644 --- a/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs @@ -39,7 +39,7 @@ public class RarReaderAsyncTests : ReaderTests private async ValueTask DoRar_Multi_Reader_Async(string[] archives) { using ( - IReader baseReader = RarReader.Open( + IReader baseReader = RarReader.OpenReader( archives .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) .Select(p => File.OpenRead(p)) @@ -72,7 +72,7 @@ public class RarReaderAsyncTests : ReaderTests "Rar.EncryptedParts.part06.rar", ]; using ( - IReader baseReader = RarReader.Open( + IReader baseReader = RarReader.OpenReader( archives .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) .Select(p => File.OpenRead(p)), @@ -127,7 +127,7 @@ public class RarReaderAsyncTests : ReaderTests .Select(s => Path.Combine(SCRATCH2_FILES_PATH, s)) .Select(File.OpenRead) .ToList(); - using (IReader baseReader = RarReader.Open(streams)) + using (IReader baseReader = RarReader.OpenReader(streams)) { IAsyncReader reader = (IAsyncReader)baseReader; while (await reader.MoveToNextEntryAsync()) @@ -208,7 +208,7 @@ public class RarReaderAsyncTests : ReaderTests 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.OpenAsync(new AsyncOnlyStream(stream))) + await using (var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream))) { while (await reader.MoveToNextEntryAsync()) { @@ -253,7 +253,7 @@ public class RarReaderAsyncTests : ReaderTests var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.Audio_program.rar")) ) await using ( - var reader = ReaderFactory.OpenAsync( + var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ) @@ -279,7 +279,7 @@ public class RarReaderAsyncTests : ReaderTests { using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg"))) using ( - IReader baseReader = RarReader.Open(stream, new ReaderOptions { LookForHeader = true }) + IReader baseReader = RarReader.OpenReader(stream, new ReaderOptions { LookForHeader = true }) ) { IAsyncReader reader = (IAsyncReader)baseReader; @@ -322,7 +322,7 @@ public class RarReaderAsyncTests : ReaderTests 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.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ); @@ -348,7 +348,7 @@ public class RarReaderAsyncTests : ReaderTests 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.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ); @@ -373,7 +373,7 @@ public class RarReaderAsyncTests : ReaderTests { 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), readerOptions ?? new ReaderOptions() ); diff --git a/tests/SharpCompress.Test/Rar/RarReaderTests.cs b/tests/SharpCompress.Test/Rar/RarReaderTests.cs index b3c98f2e..866d1d42 100644 --- a/tests/SharpCompress.Test/Rar/RarReaderTests.cs +++ b/tests/SharpCompress.Test/Rar/RarReaderTests.cs @@ -37,7 +37,7 @@ public class RarReaderTests : ReaderTests private void DoRar_Multi_Reader(string[] archives) { using ( - var reader = RarReader.Open( + var reader = RarReader.OpenReader( archives .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) .Select(p => File.OpenRead(p)) @@ -70,7 +70,7 @@ public class RarReaderTests : ReaderTests Assert.Throws(() => { using ( - var reader = RarReader.Open( + var reader = RarReader.OpenReader( archives .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)) .Select(p => File.OpenRead(p)), @@ -124,7 +124,7 @@ public class RarReaderTests : ReaderTests .Select(s => Path.Combine(SCRATCH2_FILES_PATH, s)) .Select(File.OpenRead) .ToList(); - using (var reader = RarReader.Open(streams)) + using (var reader = RarReader.OpenReader(streams)) { while (reader.MoveToNextEntry()) { @@ -193,7 +193,7 @@ public class RarReaderTests : ReaderTests private void DoRar_Entry_Stream(string filename) { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename))) - using (var reader = ReaderFactory.Open(stream)) + using (var reader = ReaderFactory.OpenReader(stream)) { while (reader.MoveToNextEntry()) { @@ -226,7 +226,7 @@ public class RarReaderTests : ReaderTests using ( var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.Audio_program.rar")) ) - using (var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true })) + using (var reader = ReaderFactory.OpenReader(stream, new ReaderOptions { LookForHeader = true })) { while (reader.MoveToNextEntry()) { @@ -247,7 +247,7 @@ public class RarReaderTests : ReaderTests public void Rar_Jpg_Reader() { using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg"))) - using (var reader = RarReader.Open(stream, new ReaderOptions { LookForHeader = true })) + using (var reader = RarReader.OpenReader(stream, new ReaderOptions { LookForHeader = true })) { while (reader.MoveToNextEntry()) { @@ -282,7 +282,7 @@ public class RarReaderTests : ReaderTests private void DoRar_Solid_Skip_Reader(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true }); + using var reader = ReaderFactory.OpenReader(stream, new ReaderOptions { LookForHeader = true }); while (reader.MoveToNextEntry()) { if (reader.Entry.Key.NotNull().Contains("jpg")) @@ -305,7 +305,7 @@ public class RarReaderTests : ReaderTests private void DoRar_Reader_Skip(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - using var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true }); + using var reader = ReaderFactory.OpenReader(stream, new ReaderOptions { LookForHeader = true }); while (reader.MoveToNextEntry()) { if (reader.Entry.Key.NotNull().Contains("jpg")) @@ -325,7 +325,7 @@ public class RarReaderTests : ReaderTests using var stream = File.OpenRead( Path.Combine(TEST_ARCHIVES_PATH, "Rar.encrypted_filesOnly.rar") ); - using var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true }); + using var reader = ReaderFactory.OpenReader(stream, new ReaderOptions { LookForHeader = true }); while (reader.MoveToNextEntry()) { // @@ -397,7 +397,7 @@ public class RarReaderTests : ReaderTests Path.Combine("exe", "test.exe"), } ); - using var reader = RarReader.Open([ + using var reader = RarReader.OpenReader([ Path.Combine(TEST_ARCHIVES_PATH, "Rar.multi.part01.rar"), Path.Combine(TEST_ARCHIVES_PATH, "Rar.multi.part02.rar"), Path.Combine(TEST_ARCHIVES_PATH, "Rar.multi.part03.rar"), diff --git a/tests/SharpCompress.Test/ReaderTests.cs b/tests/SharpCompress.Test/ReaderTests.cs index cb1dac03..039c4e51 100644 --- a/tests/SharpCompress.Test/ReaderTests.cs +++ b/tests/SharpCompress.Test/ReaderTests.cs @@ -70,7 +70,7 @@ public abstract class ReaderTests : TestBase bufferSize: options.BufferSize ); using var testStream = new TestStream(protectedStream); - using (var reader = ReaderFactory.Open(testStream, options)) + using (var reader = ReaderFactory.OpenReader(testStream, options)) { useReader(reader); protectedStream.ThrowOnDispose = false; @@ -146,7 +146,7 @@ public abstract class ReaderTests : TestBase ); using var testStream = new TestStream(protectedStream); await using ( - var reader = ReaderFactory.OpenAsync( + var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(testStream), options, cancellationToken @@ -190,7 +190,7 @@ public abstract class ReaderTests : TestBase protected void ReadForBufferBoundaryCheck(string fileName, CompressionType compressionType) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, fileName)); - using var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true }); + using var reader = ReaderFactory.OpenReader(stream, new ReaderOptions { LookForHeader = true }); while (reader.MoveToNextEntry()) { @@ -224,7 +224,7 @@ public abstract class ReaderTests : TestBase testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using var file = File.OpenRead(testArchive); using var forward = new ForwardOnlyStream(file); - using var reader = ReaderFactory.Open(forward, options); + using var reader = ReaderFactory.OpenReader(forward, options); while (reader.MoveToNextEntry()) { Assert.Equal(expectedCompression, reader.Entry.CompressionType); diff --git a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs index 7a8718ee..a7920f0b 100644 --- a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs @@ -16,7 +16,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA.7z"); using var stream = File.OpenRead(testArchive); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -29,7 +29,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests } using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None); - await using var targetStream = File.Create(targetPath); + await using var targetStream = File.CreateArchive(targetPath); await sourceStream.CopyToAsync(targetStream, CancellationToken.None); } @@ -41,7 +41,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA2.7z"); using var stream = File.OpenRead(testArchive); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -54,7 +54,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests } using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None); - await using var targetStream = File.Create(targetPath); + await using var targetStream = File.CreateArchive(targetPath); await sourceStream.CopyToAsync(targetStream, CancellationToken.None); } @@ -66,7 +66,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.solid.7z"); using var stream = File.OpenRead(testArchive); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -79,7 +79,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests } using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None); - await using var targetStream = File.Create(targetPath); + await using var targetStream = File.CreateArchive(targetPath); await sourceStream.CopyToAsync(targetStream, CancellationToken.None); } @@ -91,7 +91,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.BZip2.7z"); using var stream = File.OpenRead(testArchive); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -104,7 +104,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests } using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None); - await using var targetStream = File.Create(targetPath); + await using var targetStream = File.CreateArchive(targetPath); await sourceStream.CopyToAsync(targetStream, CancellationToken.None); } @@ -116,7 +116,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests { var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.PPMd.7z"); using var stream = File.OpenRead(testArchive); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { @@ -129,7 +129,7 @@ public class SevenZipArchiveAsyncTests : ArchiveTests } using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None); - await using var targetStream = File.Create(targetPath); + await using var targetStream = File.CreateArchive(targetPath); await sourceStream.CopyToAsync(targetStream, CancellationToken.None); } diff --git a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs index af21ff94..6cbdc87e 100644 --- a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs +++ b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs @@ -132,7 +132,7 @@ public class SevenZipArchiveTests : ArchiveTests public void SevenZipArchive_Copy_CompressionType() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "7Zip.Copy.7z"))) - using (var archive = SevenZipArchive.Open(stream)) + using (var archive = SevenZipArchive.OpenArchive(stream)) { foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) { @@ -205,7 +205,7 @@ public class SevenZipArchiveTests : ArchiveTests public void SevenZipArchive_Tar_PathRead() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "7Zip.Tar.tar.7z"))) - using (var archive = SevenZipArchive.Open(stream)) + using (var archive = SevenZipArchive.OpenArchive(stream)) { var entry = archive.Entries.First(); entry.WriteToFile(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); @@ -227,7 +227,7 @@ public class SevenZipArchiveTests : ArchiveTests [Fact] public void SevenZipArchive_TestEncryptedDetection() { - using var passwordProtectedFilesArchive = SevenZipArchive.Open( + using var passwordProtectedFilesArchive = SevenZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "7Zip.encryptedFiles.7z") ); Assert.True(passwordProtectedFilesArchive.IsEncrypted); @@ -236,17 +236,17 @@ public class SevenZipArchiveTests : ArchiveTests [Fact] public void SevenZipArchive_TestSolidDetection() { - using var oneBlockSolidArchive = SevenZipArchive.Open( + using var oneBlockSolidArchive = SevenZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "7Zip.solid.1block.7z") ); Assert.True(oneBlockSolidArchive.IsSolid); - using var solidArchive = SevenZipArchive.Open( + using var solidArchive = SevenZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "7Zip.solid.7z") ); Assert.True(solidArchive.IsSolid); - using var nonSolidArchive = SevenZipArchive.Open( + using var nonSolidArchive = SevenZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "7Zip.nonsolid.7z") ); Assert.False(nonSolidArchive.IsSolid); diff --git a/tests/SharpCompress.Test/Streams/ZLibBaseStreamAsyncTests.cs b/tests/SharpCompress.Test/Streams/ZLibBaseStreamAsyncTests.cs index a29477da..39c9f92b 100644 --- a/tests/SharpCompress.Test/Streams/ZLibBaseStreamAsyncTests.cs +++ b/tests/SharpCompress.Test/Streams/ZLibBaseStreamAsyncTests.cs @@ -86,7 +86,7 @@ public class ZLibBaseStreamAsyncTests private async ValueTask CompressAsync(Stream input, Stream output, int compressionLevel) { using var zlibStream = new ZlibStream( - SharpCompressStream.Create(output, leaveOpen: true), + SharpCompressStream.CreateArchive(output, leaveOpen: true), CompressionMode.Compress, (CompressionLevel)compressionLevel ); @@ -97,7 +97,7 @@ public class ZLibBaseStreamAsyncTests private async ValueTask DecompressAsync(Stream input, Stream output) { using var zlibStream = new ZlibStream( - SharpCompressStream.Create(input, leaveOpen: true), + SharpCompressStream.CreateArchive(input, leaveOpen: true), CompressionMode.Decompress ); await zlibStream.CopyToAsync(output).ConfigureAwait(false); diff --git a/tests/SharpCompress.Test/Streams/ZlibBaseStreamTests.cs b/tests/SharpCompress.Test/Streams/ZlibBaseStreamTests.cs index 5808078c..7a5d547e 100644 --- a/tests/SharpCompress.Test/Streams/ZlibBaseStreamTests.cs +++ b/tests/SharpCompress.Test/Streams/ZlibBaseStreamTests.cs @@ -80,7 +80,7 @@ public class ZLibBaseStreamTests private void Compress(Stream input, Stream output, int compressionLevel) { using var zlibStream = new ZlibStream( - SharpCompressStream.Create(output, leaveOpen: true), + SharpCompressStream.CreateArchive(output, leaveOpen: true), CompressionMode.Compress, (CompressionLevel)compressionLevel ); @@ -91,7 +91,7 @@ public class ZLibBaseStreamTests private void Decompress(Stream input, Stream output) { using var zlibStream = new ZlibStream( - SharpCompressStream.Create(input, leaveOpen: true), + SharpCompressStream.CreateArchive(input, leaveOpen: true), CompressionMode.Decompress ); zlibStream.CopyTo(output); diff --git a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs index f7758bb3..8de94f65 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs @@ -33,7 +33,7 @@ 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(stream, ArchiveType.Tar, CompressionType.None)) + using (var writer = WriterFactory.OpenAsyncWriter(stream, ArchiveType.Tar, CompressionType.None)) using (Stream inputStream = new MemoryStream()) { var sw = new StreamWriter(inputStream); @@ -47,7 +47,7 @@ public class TarArchiveAsyncTests : ArchiveTests // Step 2: check if the written tar file can be read correctly var unmodified = Path.Combine(SCRATCH2_FILES_PATH, archive); await using ( - var archive2 = TarArchive.OpenAsync(new AsyncOnlyStream(File.OpenRead(unmodified))) + var archive2 = TarArchive.OpenAsyncArchive(new AsyncOnlyStream(File.OpenRead(unmodified))) ) { Assert.Equal(1, await archive2.EntriesAsync.CountAsync()); @@ -82,7 +82,7 @@ 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(stream, ArchiveType.Tar, CompressionType.None)) + using (var writer = WriterFactory.OpenAsyncWriter(stream, ArchiveType.Tar, CompressionType.None)) using (Stream inputStream = new MemoryStream()) { var sw = new StreamWriter(inputStream); @@ -96,7 +96,7 @@ public class TarArchiveAsyncTests : ArchiveTests // Step 2: check if the written tar file can be read correctly var unmodified = Path.Combine(SCRATCH2_FILES_PATH, archive); await using ( - var archive2 = TarArchive.OpenAsync(new AsyncOnlyStream(File.OpenRead(unmodified))) + var archive2 = TarArchive.OpenAsyncArchive(new AsyncOnlyStream(File.OpenRead(unmodified))) ) { Assert.Equal(1, await archive2.EntriesAsync.CountAsync()); @@ -121,7 +121,7 @@ public class TarArchiveAsyncTests : ArchiveTests var scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.tar"); var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar"); - using (var archive = TarArchive.Create()) + using (var archive = TarArchive.CreateArchive()) { archive.AddAllFromDirectory(ORIGINAL_FILES_PATH); var twopt = new TarWriterOptions(CompressionType.None, true); @@ -139,7 +139,7 @@ public class TarArchiveAsyncTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar"); - await using (var archive = TarArchive.OpenAsync(unmodified)) + await using (var archive = TarArchive.OpenAsyncArchive(unmodified)) { archive.AddEntry("jpg\\test.jpg", jpg); await archive.SaveToAsync(scratchPath, new WriterOptions(CompressionType.None)); @@ -154,7 +154,7 @@ public class TarArchiveAsyncTests : ArchiveTests var modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar"); var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar"); - await using (var archive = TarArchive.OpenAsync(unmodified)) + await using (var archive = TarArchive.OpenAsyncArchive(unmodified)) { var entry = await archive.EntriesAsync.SingleAsync(x => x.Key.NotNull().EndsWith("jpg", StringComparison.OrdinalIgnoreCase) @@ -183,7 +183,7 @@ public class TarArchiveAsyncTests : ArchiveTests using (var inputMemory = new MemoryStream(mstm.ToArray())) { var tropt = new ReaderOptions { ArchiveEncoding = enc }; - await using (var tr = ReaderFactory.OpenAsync(inputMemory, tropt)) + await using (var tr = ReaderFactory.OpenAsyncReader(inputMemory, tropt)) { while (await tr.MoveToNextEntryAsync()) { @@ -216,7 +216,7 @@ public class TarArchiveAsyncTests : ArchiveTests var numberOfEntries = 0; - await using (var archiveFactory = TarArchive.OpenAsync(new AsyncOnlyStream(memoryStream))) + await using (var archiveFactory = TarArchive.OpenAsyncArchive(new AsyncOnlyStream(memoryStream))) { await foreach (var entry in archiveFactory.EntriesAsync) { diff --git a/tests/SharpCompress.Test/Tar/TarArchiveDirectoryTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveDirectoryTests.cs index 3046246d..f5d3ad73 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveDirectoryTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveDirectoryTests.cs @@ -12,7 +12,7 @@ public class TarArchiveDirectoryTests : TestBase [Fact] public void TarArchive_AddDirectoryEntry_CreatesDirectoryEntry() { - using var archive = TarArchive.Create(); + using var archive = TarArchive.CreateArchive(); archive.AddDirectoryEntry("test-dir", DateTime.Now); @@ -25,7 +25,7 @@ public class TarArchiveDirectoryTests : TestBase [Fact] public void TarArchive_AddDirectoryEntry_MultipleDirectories() { - using var archive = TarArchive.Create(); + using var archive = TarArchive.CreateArchive(); archive.AddDirectoryEntry("dir1", DateTime.Now); archive.AddDirectoryEntry("dir2", DateTime.Now); @@ -39,7 +39,7 @@ public class TarArchiveDirectoryTests : TestBase [Fact] public void TarArchive_AddDirectoryEntry_MixedWithFiles() { - using var archive = TarArchive.Create(); + using var archive = TarArchive.CreateArchive(); archive.AddDirectoryEntry("dir1", DateTime.Now); @@ -62,7 +62,7 @@ public class TarArchiveDirectoryTests : TestBase { var scratchPath = Path.Combine(SCRATCH_FILES_PATH, "tar-directory-test.tar"); - using (var archive = TarArchive.Create()) + using (var archive = TarArchive.CreateArchive()) { archive.AddDirectoryEntry("dir1", DateTime.Now); archive.AddDirectoryEntry("dir2", DateTime.Now); @@ -84,7 +84,7 @@ public class TarArchiveDirectoryTests : TestBase } } - using (var archive = TarArchive.Open(scratchPath)) + using (var archive = TarArchive.OpenArchive(scratchPath)) { var entries = archive.Entries.OrderBy(e => e.Key).ToList(); Assert.Equal(3, entries.Count); @@ -103,7 +103,7 @@ public class TarArchiveDirectoryTests : TestBase [Fact] public void TarArchive_AddDirectoryEntry_DuplicateKey_ThrowsException() { - using var archive = TarArchive.Create(); + using var archive = TarArchive.CreateArchive(); archive.AddDirectoryEntry("test-dir", DateTime.Now); diff --git a/tests/SharpCompress.Test/Tar/TarArchiveTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveTests.cs index 0f92681c..af33dff7 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveTests.cs @@ -34,7 +34,7 @@ public class TarArchiveTests : 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.Open(stream, ArchiveType.Tar, CompressionType.None)) + using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, CompressionType.None)) using (Stream inputStream = new MemoryStream()) { var sw = new StreamWriter(inputStream); @@ -47,7 +47,7 @@ public class TarArchiveTests : ArchiveTests // Step 2: check if the written tar file can be read correctly var unmodified = Path.Combine(SCRATCH2_FILES_PATH, archive); - using (var archive2 = TarArchive.Open(unmodified)) + using (var archive2 = TarArchive.OpenArchive(unmodified)) { Assert.Equal(1, archive2.Entries.Count()); Assert.Contains(filename, archive2.Entries.Select(entry => entry.Key)); @@ -66,7 +66,7 @@ public class TarArchiveTests : ArchiveTests public void Tar_NonUstarArchiveWithLongNameDoesNotSkipEntriesAfterTheLongOne() { var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "very long filename.tar"); - using var archive = TarArchive.Open(unmodified); + using var archive = TarArchive.OpenArchive(unmodified); Assert.Equal(5, archive.Entries.Count()); Assert.Contains("very long filename/", archive.Entries.Select(entry => entry.Key)); Assert.Contains( @@ -94,7 +94,7 @@ public class TarArchiveTests : 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.Open(stream, ArchiveType.Tar, CompressionType.None)) + using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, CompressionType.None)) using (Stream inputStream = new MemoryStream()) { var sw = new StreamWriter(inputStream); @@ -107,7 +107,7 @@ public class TarArchiveTests : ArchiveTests // Step 2: check if the written tar file can be read correctly var unmodified = Path.Combine(SCRATCH2_FILES_PATH, archive); - using (var archive2 = TarArchive.Open(unmodified)) + using (var archive2 = TarArchive.OpenArchive(unmodified)) { Assert.Equal(1, archive2.Entries.Count()); Assert.Contains(longFilename, archive2.Entries.Select(entry => entry.Key)); @@ -126,7 +126,7 @@ public class TarArchiveTests : ArchiveTests public void Tar_UstarArchivePathReadLongName() { var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "ustar with long names.tar"); - using var archive = TarArchive.Open(unmodified); + using var archive = TarArchive.OpenArchive(unmodified); Assert.Equal(6, archive.Entries.Count()); Assert.Contains("Directory/", archive.Entries.Select(entry => entry.Key)); Assert.Contains( @@ -159,7 +159,7 @@ public class TarArchiveTests : ArchiveTests // var aropt = new Ar - using (var archive = TarArchive.Create()) + using (var archive = TarArchive.CreateArchive()) { archive.AddAllFromDirectory(ORIGINAL_FILES_PATH); var twopt = new TarWriterOptions(CompressionType.None, true); @@ -177,7 +177,7 @@ public class TarArchiveTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar"); - using (var archive = TarArchive.Open(unmodified)) + using (var archive = TarArchive.OpenArchive(unmodified)) { archive.AddEntry("jpg\\test.jpg", jpg); archive.SaveTo(scratchPath, CompressionType.None); @@ -192,7 +192,7 @@ public class TarArchiveTests : ArchiveTests var modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar"); var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar"); - using (var archive = TarArchive.Open(unmodified)) + using (var archive = TarArchive.OpenArchive(unmodified)) { var entry = archive.Entries.Single(x => x.Key.NotNull().EndsWith("jpg", StringComparison.OrdinalIgnoreCase) @@ -208,7 +208,7 @@ public class TarArchiveTests : ArchiveTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.ContainsRar.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); Assert.True(archive.Type == ArchiveType.Tar); } @@ -217,7 +217,7 @@ public class TarArchiveTests : ArchiveTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.Empty.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var archive = ArchiveFactory.Open(stream); + using var archive = ArchiveFactory.OpenArchive(stream); Assert.True(archive.Type == ArchiveType.Tar); } @@ -239,7 +239,7 @@ public class TarArchiveTests : ArchiveTests using (var inputMemory = new MemoryStream(mstm.ToArray())) { var tropt = new ReaderOptions { ArchiveEncoding = enc }; - using (var tr = TarReader.Open(inputMemory, tropt)) + using (var tr = TarReader.OpenReader(inputMemory, tropt)) { while (tr.MoveToNextEntry()) { @@ -272,7 +272,7 @@ public class TarArchiveTests : ArchiveTests var numberOfEntries = 0; - using (var archiveFactory = TarArchive.Open(memoryStream)) + using (var archiveFactory = TarArchive.OpenArchive(memoryStream)) { foreach (var entry in archiveFactory.Entries) { diff --git a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs index 1a18f3ce..7ce0d9b2 100644 --- a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs @@ -23,7 +23,7 @@ public class TarReaderAsyncTests : ReaderTests using Stream stream = new ForwardOnlyStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")) ); - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)); var x = 0; while (await reader.MoveToNextEntryAsync()) { @@ -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(stream)) + await using (var reader = ReaderFactory.OpenAsyncReader(stream)) { while (await reader.MoveToNextEntryAsync()) { @@ -110,7 +110,7 @@ public class TarReaderAsyncTests : ReaderTests Path.Combine(TEST_ARCHIVES_PATH, "Tar.LongPathsWithLongNameExtension.tar") ) ) - using (var reader = TarReader.Open(stream)) + using (var reader = TarReader.OpenReader(stream)) { while (reader.MoveToNextEntry()) { @@ -137,7 +137,7 @@ public class TarReaderAsyncTests : ReaderTests public void Tar_BZip2_Skip_Entry_Stream_Async() { using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.bz2")); - using var reader = TarReader.Open(stream); + using var reader = TarReader.OpenReader(stream); var names = new List(); while (reader.MoveToNextEntry()) { @@ -157,7 +157,7 @@ public class TarReaderAsyncTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.ContainsRar.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); Assert.True(reader.ArchiveType == ArchiveType.Tar); } @@ -166,7 +166,7 @@ public class TarReaderAsyncTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.ContainsTarGz.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); Assert.True(reader.MoveToNextEntry()); Assert.Equal("inner.tar.gz", reader.Entry.Key); @@ -174,7 +174,7 @@ public class TarReaderAsyncTests : ReaderTests using var flushingStream = new FlushOnDisposeStream(entryStream); // Extract inner.tar.gz - using var innerReader = ReaderFactory.Open(flushingStream); + using var innerReader = ReaderFactory.OpenReader(flushingStream); Assert.True(innerReader.MoveToNextEntry()); Assert.Equal("test", innerReader.Entry.Key); } @@ -184,7 +184,7 @@ public class TarReaderAsyncTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"); using Stream stream = File.OpenRead(archiveFullPath); - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)); var memoryStream = new MemoryStream(); Assert.True(await reader.MoveToNextEntryAsync()); @@ -201,7 +201,7 @@ public class TarReaderAsyncTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "TarCorrupted.tar"); using Stream stream = File.OpenRead(archiveFullPath); - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)); var memoryStream = new MemoryStream(); Assert.True(await reader.MoveToNextEntryAsync()); @@ -220,7 +220,7 @@ public class TarReaderAsyncTests : ReaderTests using Stream stream = File.OpenRead( Path.Combine(TEST_ARCHIVES_PATH, "TarWithSymlink.tar.gz") ); - await using var reader = ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsyncReader( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ); diff --git a/tests/SharpCompress.Test/Tar/TarReaderTests.cs b/tests/SharpCompress.Test/Tar/TarReaderTests.cs index c4763b3c..2f0b9248 100644 --- a/tests/SharpCompress.Test/Tar/TarReaderTests.cs +++ b/tests/SharpCompress.Test/Tar/TarReaderTests.cs @@ -22,7 +22,7 @@ public class TarReaderTests : ReaderTests using Stream stream = new ForwardOnlyStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")) ); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); var x = 0; while (reader.MoveToNextEntry()) { @@ -65,7 +65,7 @@ public class TarReaderTests : ReaderTests public void Tar_BZip2_Entry_Stream() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.bz2"))) - using (var reader = TarReader.Open(stream)) + using (var reader = TarReader.OpenReader(stream)) { while (reader.MoveToNextEntry()) { @@ -102,7 +102,7 @@ public class TarReaderTests : ReaderTests Path.Combine(TEST_ARCHIVES_PATH, "Tar.LongPathsWithLongNameExtension.tar") ) ) - using (var reader = TarReader.Open(stream)) + using (var reader = TarReader.OpenReader(stream)) { while (reader.MoveToNextEntry()) { @@ -129,7 +129,7 @@ public class TarReaderTests : ReaderTests public void Tar_BZip2_Skip_Entry_Stream() { using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.bz2")); - using var reader = TarReader.Open(stream); + using var reader = TarReader.OpenReader(stream); var names = new List(); while (reader.MoveToNextEntry()) { @@ -149,7 +149,7 @@ public class TarReaderTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.ContainsRar.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); Assert.True(reader.ArchiveType == ArchiveType.Tar); } @@ -158,7 +158,7 @@ public class TarReaderTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.ContainsTarGz.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); Assert.True(reader.MoveToNextEntry()); Assert.Equal("inner.tar.gz", reader.Entry.Key); @@ -166,7 +166,7 @@ public class TarReaderTests : ReaderTests using var flushingStream = new FlushOnDisposeStream(entryStream); // Extract inner.tar.gz - using var innerReader = ReaderFactory.Open(flushingStream); + using var innerReader = ReaderFactory.OpenReader(flushingStream); Assert.True(innerReader.MoveToNextEntry()); Assert.Equal("test", innerReader.Entry.Key); } @@ -176,7 +176,7 @@ public class TarReaderTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); var memoryStream = new MemoryStream(); Assert.True(reader.MoveToNextEntry()); @@ -191,7 +191,7 @@ public class TarReaderTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "TarCorrupted.tar"); using Stream stream = File.OpenRead(archiveFullPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); var memoryStream = new MemoryStream(); Assert.True(reader.MoveToNextEntry()); @@ -208,7 +208,7 @@ public class TarReaderTests : ReaderTests using Stream stream = File.OpenRead( Path.Combine(TEST_ARCHIVES_PATH, "TarWithSymlink.tar.gz") ); - using var reader = TarReader.Open(stream); + using var reader = TarReader.OpenReader(stream); while (reader.MoveToNextEntry()) { if (reader.Entry.IsDirectory) @@ -304,7 +304,7 @@ public class TarReaderTests : ReaderTests // The important thing is it doesn't cause OutOfMemoryException Assert.Throws(() => { - using var reader = TarReader.Open(stream); + using var reader = TarReader.OpenReader(stream); reader.MoveToNextEntry(); }); } diff --git a/tests/SharpCompress.Test/Tar/TarWriterDirectoryTests.cs b/tests/SharpCompress.Test/Tar/TarWriterDirectoryTests.cs index e0b5d821..b900f9b5 100644 --- a/tests/SharpCompress.Test/Tar/TarWriterDirectoryTests.cs +++ b/tests/SharpCompress.Test/Tar/TarWriterDirectoryTests.cs @@ -25,7 +25,7 @@ public class TarWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = TarArchive.Open(memoryStream); + using var archive = TarArchive.OpenArchive(memoryStream); var entries = archive.Entries.ToList(); Assert.Single(entries); @@ -48,7 +48,7 @@ public class TarWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = TarArchive.Open(memoryStream); + using var archive = TarArchive.OpenArchive(memoryStream); var entries = archive.Entries.ToList(); Assert.Single(entries); @@ -71,7 +71,7 @@ public class TarWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = TarArchive.Open(memoryStream); + using var archive = TarArchive.OpenArchive(memoryStream); var entries = archive.Entries.ToList(); Assert.Single(entries); @@ -94,7 +94,7 @@ public class TarWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = TarArchive.Open(memoryStream); + using var archive = TarArchive.OpenArchive(memoryStream); Assert.Empty(archive.Entries); } @@ -116,7 +116,7 @@ public class TarWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = TarArchive.Open(memoryStream); + using var archive = TarArchive.OpenArchive(memoryStream); var entries = archive.Entries.OrderBy(e => e.Key).ToList(); Assert.Equal(3, entries.Count); @@ -150,7 +150,7 @@ public class TarWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = TarArchive.Open(memoryStream); + using var archive = TarArchive.OpenArchive(memoryStream); var entries = archive.Entries.OrderBy(e => e.Key).ToList(); Assert.Equal(3, entries.Count); diff --git a/tests/SharpCompress.Test/TestBase.cs b/tests/SharpCompress.Test/TestBase.cs index 702d6bca..5a5ea765 100644 --- a/tests/SharpCompress.Test/TestBase.cs +++ b/tests/SharpCompress.Test/TestBase.cs @@ -228,8 +228,8 @@ public class TestBase : IAsyncDisposable //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)) + using (var archive1 = ReaderFactory.OpenArchive(File.OpenRead(file1), readerOptions)) + using (var archive2 = ReaderFactory.OpenArchive(File.OpenRead(file2), readerOptions)) { while (archive1.MoveToNextEntry()) { diff --git a/tests/SharpCompress.Test/WriterTests.cs b/tests/SharpCompress.Test/WriterTests.cs index 95d82da3..bb16ac03 100644 --- a/tests/SharpCompress.Test/WriterTests.cs +++ b/tests/SharpCompress.Test/WriterTests.cs @@ -29,7 +29,7 @@ public class WriterTests : TestBase writerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; - using var writer = WriterFactory.Open(stream, _type, writerOptions); + using var writer = WriterFactory.OpenArchive(stream, _type, writerOptions); writer.WriteAll(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories); } CompareArchivesByPath( @@ -43,8 +43,8 @@ public class WriterTests : TestBase readerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; - using var reader = ReaderFactory.Open( - SharpCompressStream.Create(stream, leaveOpen: true), + using var reader = ReaderFactory.OpenArchive( + SharpCompressStream.CreateArchive(stream, leaveOpen: true), readerOptions ); reader.WriteAllToDirectory( @@ -73,7 +73,7 @@ public class WriterTests : TestBase writerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; - using var writer = WriterFactory.OpenAsync(stream, _type, writerOptions); + using var writer = WriterFactory.OpenAsyncArchive(stream, _type, writerOptions); await writer.WriteAllAsync( ORIGINAL_FILES_PATH, "*", @@ -92,8 +92,8 @@ public class WriterTests : TestBase readerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; - await using var reader = ReaderFactory.OpenAsync( - new AsyncOnlyStream(SharpCompressStream.Create(stream, leaveOpen: true)), + await using var reader = ReaderFactory.OpenAsyncArchive( + new AsyncOnlyStream(SharpCompressStream.CreateArchive(stream, leaveOpen: true)), readerOptions, cancellationToken ); diff --git a/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs b/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs index eab7e1c7..f1b53f61 100644 --- a/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs @@ -177,7 +177,7 @@ public class Zip64AsyncTests : WriterTests using var zip = File.OpenWrite(filename); using var st = forwardOnly ? (Stream)new ForwardOnlyStream(zip) : zip; - using var zipWriter = (ZipWriter)WriterFactory.Open(st, ArchiveType.Zip, opts); + using var zipWriter = (ZipWriter)WriterFactory.OpenWriter(st, ArchiveType.Zip, opts); for (var i = 0; i < files; i++) { using var str = zipWriter.WriteToStream(i.ToString(), eo); @@ -199,7 +199,7 @@ public class Zip64AsyncTests : WriterTests ZipEntry? prev = null; using (var fs = File.OpenRead(filename)) { - var rd = ReaderFactory.OpenAsync(fs, new ReaderOptions { LookForHeader = false }); + var rd = ReaderFactory.OpenAsyncReader(fs, new ReaderOptions { LookForHeader = false }); await using (rd) { while (await rd.MoveToNextEntryAsync()) @@ -236,7 +236,7 @@ public class Zip64AsyncTests : WriterTests public Tuple ReadArchive(string filename) { - using var archive = ArchiveFactory.Open(filename); + using var archive = ArchiveFactory.OpenArchive(filename); return new Tuple( archive.Entries.Count(), archive.Entries.Select(x => x.Size).Sum() diff --git a/tests/SharpCompress.Test/Zip/Zip64Tests.cs b/tests/SharpCompress.Test/Zip/Zip64Tests.cs index dc733df0..6242b877 100644 --- a/tests/SharpCompress.Test/Zip/Zip64Tests.cs +++ b/tests/SharpCompress.Test/Zip/Zip64Tests.cs @@ -162,7 +162,7 @@ public class Zip64Tests : WriterTests using var zip = File.OpenWrite(filename); using var st = forwardOnly ? (Stream)new ForwardOnlyStream(zip) : zip; - using var zipWriter = (ZipWriter)WriterFactory.Open(st, ArchiveType.Zip, opts); + using var zipWriter = (ZipWriter)WriterFactory.OpenWriter(st, ArchiveType.Zip, opts); for (var i = 0; i < files; i++) { using var str = zipWriter.WriteToStream(i.ToString(), eo); @@ -182,7 +182,7 @@ public class Zip64Tests : WriterTests long size = 0; IEntry? prev = null; using (var fs = File.OpenRead(filename)) - using (var rd = ZipReader.Open(fs, new ReaderOptions { LookForHeader = false })) + using (var rd = ZipReader.OpenReader(fs, new ReaderOptions { LookForHeader = false })) { while (rd.MoveToNextEntry()) { @@ -208,7 +208,7 @@ public class Zip64Tests : WriterTests public Tuple ReadArchive(string filename) { - using var archive = ArchiveFactory.Open(filename); + using var archive = ArchiveFactory.OpenArchive(filename); return new Tuple( archive.Entries.Count(), archive.Entries.Select(x => x.Size).Sum() diff --git a/tests/SharpCompress.Test/Zip/Zip64VersionConsistencyTests.cs b/tests/SharpCompress.Test/Zip/Zip64VersionConsistencyTests.cs index b8451a45..b3a03342 100644 --- a/tests/SharpCompress.Test/Zip/Zip64VersionConsistencyTests.cs +++ b/tests/SharpCompress.Test/Zip/Zip64VersionConsistencyTests.cs @@ -37,7 +37,7 @@ public class Zip64VersionConsistencyTests : WriterTests UseZip64 = true, }; - ZipArchive zipArchive = ZipArchive.Create(); + ZipArchive zipArchive = ZipArchive.CreateArchive(); zipArchive.AddEntry("empty", new MemoryStream()); zipArchive.SaveTo(filename, writerOptions); @@ -141,7 +141,7 @@ public class Zip64VersionConsistencyTests : WriterTests UseZip64 = false, }; - ZipArchive zipArchive = ZipArchive.Create(); + ZipArchive zipArchive = ZipArchive.CreateArchive(); zipArchive.AddEntry("empty", new MemoryStream()); zipArchive.SaveTo(filename, writerOptions); @@ -192,7 +192,7 @@ public class Zip64VersionConsistencyTests : WriterTests UseZip64 = false, }; - ZipArchive zipArchive = ZipArchive.Create(); + ZipArchive zipArchive = ZipArchive.CreateArchive(); var data = new byte[100]; new Random(42).NextBytes(data); zipArchive.AddEntry("test.bin", new MemoryStream(data)); @@ -245,7 +245,7 @@ public class Zip64VersionConsistencyTests : WriterTests UseZip64 = false, }; - ZipArchive zipArchive = ZipArchive.Create(); + ZipArchive zipArchive = ZipArchive.CreateArchive(); var data = new byte[100]; new Random(42).NextBytes(data); zipArchive.AddEntry("test.bin", new MemoryStream(data)); @@ -298,7 +298,7 @@ public class Zip64VersionConsistencyTests : WriterTests UseZip64 = true, }; - ZipArchive zipArchive = ZipArchive.Create(); + ZipArchive zipArchive = ZipArchive.CreateArchive(); for (int i = 0; i < 5; i++) { var data = new byte[100]; diff --git a/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs index ecc1c9c8..d16bec4f 100644 --- a/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs @@ -126,7 +126,7 @@ public class ZipArchiveAsyncTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip"); - await using (var archive = ZipArchive.OpenAsync(unmodified)) + await using (var archive = ZipArchive.OpenAsyncArchive(unmodified)) { var entry = await archive.EntriesAsync.SingleAsync(x => x.Key.NotNull().EndsWith("jpg", StringComparison.OrdinalIgnoreCase) @@ -149,7 +149,7 @@ public class ZipArchiveAsyncTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - await using (var archive = ZipArchive.OpenAsync(unmodified)) + await using (var archive = ZipArchive.OpenAsyncArchive(unmodified)) { archive.AddEntry("jpg\\test.jpg", jpg); @@ -167,7 +167,7 @@ public class ZipArchiveAsyncTests : ArchiveTests var scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Zip.deflate.noEmptyDirs.zip"); var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - using (ZipArchive archive = ZipArchive.Create()) + using (ZipArchive archive = ZipArchive.CreateArchive()) { archive.DeflateCompressionLevel = CompressionLevel.BestSpeed; archive.AddAllFromDirectory(ORIGINAL_FILES_PATH); @@ -185,7 +185,7 @@ public class ZipArchiveAsyncTests : ArchiveTests { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) { - IAsyncArchive archive = ZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + IAsyncArchive archive = ZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream)); try { await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) @@ -209,7 +209,7 @@ public class ZipArchiveAsyncTests : ArchiveTests { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) { - IAsyncArchive archive = ZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + IAsyncArchive archive = ZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream)); try { await archive.WriteToDirectoryAsync( @@ -233,7 +233,7 @@ public class ZipArchiveAsyncTests : ArchiveTests using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) { - IAsyncArchive archive = ZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + IAsyncArchive archive = ZipArchive.OpenAsyncArchive(new AsyncOnlyStream(stream)); try { await archive.WriteToDirectoryAsync( diff --git a/tests/SharpCompress.Test/Zip/ZipArchiveDirectoryTests.cs b/tests/SharpCompress.Test/Zip/ZipArchiveDirectoryTests.cs index 45bab5e3..183312cd 100644 --- a/tests/SharpCompress.Test/Zip/ZipArchiveDirectoryTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipArchiveDirectoryTests.cs @@ -12,7 +12,7 @@ public class ZipArchiveDirectoryTests : TestBase [Fact] public void ZipArchive_AddDirectoryEntry_CreatesDirectoryEntry() { - using var archive = ZipArchive.Create(); + using var archive = ZipArchive.CreateArchive(); archive.AddDirectoryEntry("test-dir", DateTime.Now); @@ -25,7 +25,7 @@ public class ZipArchiveDirectoryTests : TestBase [Fact] public void ZipArchive_AddDirectoryEntry_MultipleDirectories() { - using var archive = ZipArchive.Create(); + using var archive = ZipArchive.CreateArchive(); archive.AddDirectoryEntry("dir1", DateTime.Now); archive.AddDirectoryEntry("dir2", DateTime.Now); @@ -39,7 +39,7 @@ public class ZipArchiveDirectoryTests : TestBase [Fact] public void ZipArchive_AddDirectoryEntry_MixedWithFiles() { - using var archive = ZipArchive.Create(); + using var archive = ZipArchive.CreateArchive(); archive.AddDirectoryEntry("dir1", DateTime.Now); @@ -62,7 +62,7 @@ public class ZipArchiveDirectoryTests : TestBase { var scratchPath = Path.Combine(SCRATCH_FILES_PATH, "zip-directory-test.zip"); - using (var archive = ZipArchive.Create()) + using (var archive = ZipArchive.CreateArchive()) { archive.AddDirectoryEntry("dir1", DateTime.Now); archive.AddDirectoryEntry("dir2", DateTime.Now); @@ -84,7 +84,7 @@ public class ZipArchiveDirectoryTests : TestBase } } - using (var archive = ZipArchive.Open(scratchPath)) + using (var archive = ZipArchive.OpenArchive(scratchPath)) { var entries = archive.Entries.OrderBy(e => e.Key).ToList(); Assert.Equal(3, entries.Count); @@ -103,7 +103,7 @@ public class ZipArchiveDirectoryTests : TestBase [Fact] public void ZipArchive_AddDirectoryEntry_DuplicateKey_ThrowsException() { - using var archive = ZipArchive.Create(); + using var archive = ZipArchive.CreateArchive(); archive.AddDirectoryEntry("test-dir", DateTime.Now); diff --git a/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs b/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs index a8192416..562fc09d 100644 --- a/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs @@ -235,7 +235,7 @@ public class ZipArchiveTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip"); - using (var archive = ZipArchive.Open(unmodified)) + using (var archive = ZipArchive.OpenArchive(unmodified)) { var entry = archive.Entries.Single(x => x.Key.NotNull().EndsWith("jpg", StringComparison.OrdinalIgnoreCase) @@ -258,7 +258,7 @@ public class ZipArchiveTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod2.zip"); - using (var archive = ZipArchive.Open(unmodified)) + using (var archive = ZipArchive.OpenArchive(unmodified)) { archive.AddEntry("jpg\\test.jpg", jpg); @@ -276,7 +276,7 @@ public class ZipArchiveTests : ArchiveTests var scratchPath1 = Path.Combine(SCRATCH_FILES_PATH, "a.zip"); var scratchPath2 = Path.Combine(SCRATCH_FILES_PATH, "b.zip"); - using (var arc = ZipArchive.Create()) + using (var arc = ZipArchive.CreateArchive()) { var str = "test.txt"; var source = new MemoryStream(Encoding.UTF8.GetBytes(str)); @@ -293,7 +293,7 @@ public class ZipArchiveTests : ArchiveTests { var scratchPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - using var vfs = (ZipArchive)ArchiveFactory.Open(scratchPath); + using var vfs = (ZipArchive)ArchiveFactory.OpenArchive(scratchPath); var e = vfs.Entries.First(v => v.Key.NotNull().EndsWith("jpg", StringComparison.OrdinalIgnoreCase) ); @@ -313,7 +313,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void Zip_Create_NoDups() { - using var arc = ZipArchive.Create(); + using var arc = ZipArchive.CreateArchive(); arc.AddEntry("1.txt", new MemoryStream()); Assert.Throws(() => arc.AddEntry("\\1.txt", new MemoryStream())); } @@ -324,7 +324,7 @@ public class ZipArchiveTests : ArchiveTests var scratchPath1 = Path.Combine(SCRATCH_FILES_PATH, "a.zip"); var scratchPath2 = Path.Combine(SCRATCH_FILES_PATH, "b.zip"); - using (var arc = ZipArchive.Create()) + using (var arc = ZipArchive.CreateArchive()) { using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("qwert"))) { @@ -370,7 +370,7 @@ public class ZipArchiveTests : ArchiveTests var scratchPath = Path.Combine(SCRATCH2_FILES_PATH, "Zip.deflate.noEmptyDirs.zip"); var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - using (var archive = ZipArchive.Create()) + using (var archive = ZipArchive.CreateArchive()) { archive.AddAllFromDirectory(SCRATCH_FILES_PATH); @@ -389,7 +389,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void Zip_Create_Empty_And_Read() { - var archive = ZipArchive.Create(); + var archive = ZipArchive.CreateArchive(); var archiveStream = new MemoryStream(); @@ -397,7 +397,7 @@ public class ZipArchiveTests : ArchiveTests archiveStream.Position = 0; - var readArchive = ArchiveFactory.Open(archiveStream); + var readArchive = ArchiveFactory.OpenArchive(archiveStream); var count = readArchive.Entries.Count(); @@ -435,7 +435,7 @@ public class ZipArchiveTests : ArchiveTests } var scratchPath = Path.Combine(SCRATCH2_FILES_PATH, "Zip.deflate.noEmptyDirs.zip"); - using (var archive = ZipArchive.Create()) + using (var archive = ZipArchive.CreateArchive()) { archive.AddAllFromDirectory(SCRATCH_FILES_PATH); archive.RemoveEntry( @@ -455,7 +455,7 @@ public class ZipArchiveTests : ArchiveTests public void Zip_Deflate_WinzipAES_Read() { using ( - var reader = ZipArchive.Open( + var reader = ZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"), new ReaderOptions { Password = "test" } ) @@ -475,7 +475,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void Zip_Deflate_WinzipAES_MultiOpenEntryStream() { - using var reader = ZipArchive.Open( + using var reader = ZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES2.zip"), new ReaderOptions { Password = "test" } ); @@ -491,7 +491,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void Zip_Read_Volume_Comment() { - using var reader = ZipArchive.Open( + using var reader = ZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Zip.zip64.zip"), new ReaderOptions { Password = "test" } ); @@ -507,7 +507,7 @@ public class ZipArchiveTests : ArchiveTests public void Zip_BZip2_Pkware_Read() { using ( - var reader = ZipArchive.Open( + var reader = ZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip"), new ReaderOptions { Password = "test" } ) @@ -529,7 +529,7 @@ public class ZipArchiveTests : ArchiveTests { var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - var a = ZipArchive.Open(unmodified); + var a = ZipArchive.OpenArchive(unmodified); var count = 0; foreach (var e in a.Entries) { @@ -540,7 +540,7 @@ public class ZipArchiveTests : ArchiveTests Assert.Equal(3, count); a.Dispose(); - a = ZipArchive.Open(unmodified); + a = ZipArchive.OpenArchive(unmodified); var count2 = 0; foreach (var e in a.Entries) @@ -572,7 +572,7 @@ public class ZipArchiveTests : ArchiveTests var zipFile = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.pkware.zip"); using var fileStream = File.OpenRead(zipFile); - using var archive = ArchiveFactory.Open( + using var archive = ArchiveFactory.OpenArchive( fileStream, new ReaderOptions { Password = "12345678" } ); @@ -596,7 +596,7 @@ public class ZipArchiveTests : ArchiveTests Assert.ThrowsAny(() => { - using var archive = ZipArchive.Open(zipFile); + using var archive = ZipArchive.OpenArchive(zipFile); foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { entry.WriteToDirectory( @@ -618,7 +618,7 @@ public class ZipArchiveTests : ArchiveTests { MemoryStream stream = new NonSeekableMemoryStream(); - using (var zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate)) + using (var zipWriter = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate)) { zipWriter.Write("foo.txt", new MemoryStream(Array.Empty())); zipWriter.Write("foo2.txt", new MemoryStream(new byte[10])); @@ -627,7 +627,7 @@ public class ZipArchiveTests : ArchiveTests stream = new MemoryStream(stream.ToArray()); File.WriteAllBytes(Path.Combine(SCRATCH_FILES_PATH, "foo.zip"), stream.ToArray()); - using (var zipArchive = ZipArchive.Open(stream)) + using (var zipArchive = ZipArchive.OpenArchive(stream)) { foreach (var entry in zipArchive.Entries) { @@ -649,7 +649,7 @@ public class ZipArchiveTests : ArchiveTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.badlocalextra.zip"); - using var za = ZipArchive.Open(zipPath); + using var za = ZipArchive.OpenArchive(zipPath); var ex = Record.Exception(() => { var firstEntry = za.Entries.First(x => x.Key == "first.txt"); @@ -669,7 +669,7 @@ public class ZipArchiveTests : ArchiveTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.datadescriptors.zip"); - using var za = ZipArchive.Open(zipPath); + using var za = ZipArchive.OpenArchive(zipPath); var firstEntry = za.Entries.First(x => x.Key == "first.txt"); var buffer = new byte[4096]; @@ -708,7 +708,7 @@ public class ZipArchiveTests : ArchiveTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.LongComment.zip"); - using var za = ZipArchive.Open(zipPath); + using var za = ZipArchive.OpenArchive(zipPath); var count = za.Entries.Count(); Assert.Equal(1, count); } @@ -718,7 +718,7 @@ public class ZipArchiveTests : ArchiveTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.zip64.compressedonly.zip"); - using var za = ZipArchive.Open(zipPath); + using var za = ZipArchive.OpenArchive(zipPath); var firstEntry = za.Entries.First(x => x.Key == "test/test.txt"); using var memoryStream = new MemoryStream(); @@ -732,7 +732,7 @@ public class ZipArchiveTests : ArchiveTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.uncompressed.zip"); using var stream = File.OpenRead(zipPath); - var reader = ReaderFactory.Open(stream); + var reader = ReaderFactory.OpenReader(stream); var entries = 0; while (reader.MoveToNextEntry()) { @@ -760,7 +760,7 @@ public class ZipArchiveTests : ArchiveTests }; var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.uncompressed.zip"); using var stream = File.OpenRead(zipPath); - var reader = ReaderFactory.Open(stream); + var reader = ReaderFactory.OpenReader(stream); var x = 0; while (reader.MoveToNextEntry()) { @@ -777,7 +777,7 @@ public class ZipArchiveTests : ArchiveTests var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.UnicodePathExtra.zip"); using (var stream = File.OpenRead(zipPath)) { - var reader = ReaderFactory.Open( + var reader = ReaderFactory.OpenReader( stream, new ReaderOptions { @@ -792,7 +792,7 @@ public class ZipArchiveTests : ArchiveTests } using (var stream = File.OpenRead(zipPath)) { - var reader = ReaderFactory.Open( + var reader = ReaderFactory.OpenReader( stream, new ReaderOptions { @@ -810,7 +810,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void TestDataDescriptorRead() { - using var archive = ArchiveFactory.Open( + using var archive = ArchiveFactory.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.datadescriptors.zip") ); var firstEntry = archive.Entries.First(); @@ -822,7 +822,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void Zip_EntryCommentAfterEntryRead() { - using var archive = ZipArchive.Open( + using var archive = ZipArchive.OpenArchive( Path.Combine(TEST_ARCHIVES_PATH, "Zip.EntryComment.zip") ); var firstEntry = (ZipArchiveEntry)archive.Entries.First(); @@ -834,7 +834,7 @@ public class ZipArchiveTests : ArchiveTests [Fact] public void Zip_FilePermissions() { - using var archive = ArchiveFactory.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.644.zip")); + using var archive = ArchiveFactory.OpenArchive(Path.Combine(TEST_ARCHIVES_PATH, "Zip.644.zip")); var firstEntry = archive.Entries.First(); const int S_IFREG = 0x8000; diff --git a/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs index 471e8e31..d2dd3b08 100644 --- a/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs @@ -131,7 +131,7 @@ public class ZipTypesLevelsWithCrcRatioAsyncTests : ArchiveTests CompressionLevel = compressionLevel, }; - using (var writer = WriterFactory.OpenAsync(zipStream, ArchiveType.Zip, writerOptions)) + using (var writer = WriterFactory.OpenAsyncWriter(zipStream, ArchiveType.Zip, writerOptions)) { await writer.WriteAsync( $"{compressionType}_level_{compressionLevel}_{sizeMb}MiB.txt", @@ -152,7 +152,7 @@ public class ZipTypesLevelsWithCrcRatioAsyncTests : ArchiveTests // Verify the archive zipStream.Position = 0; - using var archive = ZipArchive.Open(zipStream); + using var archive = ZipArchive.OpenArchive(zipStream); var entry = archive.Entries.Single(e => !e.IsDirectory); using var entryStream = await entry.OpenEntryStreamAsync(); @@ -209,7 +209,7 @@ public class ZipTypesLevelsWithCrcRatioAsyncTests : ArchiveTests // Verify the archive zipStream.Position = 0; - using var archive = ZipArchive.Open(zipStream); + using var archive = ZipArchive.OpenArchive(zipStream); var entry = archive.Entries.Single(e => !e.IsDirectory); using var entryStream = await entry.OpenEntryStreamAsync(); @@ -248,7 +248,7 @@ public class ZipTypesLevelsWithCrcRatioAsyncTests : ArchiveTests ) { zipStream.Position = 0; - using var archive = ZipArchive.Open(zipStream); + using var archive = ZipArchive.OpenArchive(zipStream); foreach (var entry in archive.Entries.Where(e => !e.IsDirectory)) { diff --git a/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcTests.cs b/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcTests.cs index 0e66edc2..fb9226be 100644 --- a/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcTests.cs @@ -125,7 +125,7 @@ public class ZipTypesLevelsWithCrcRatioTests : ArchiveTests CompressionLevel = compressionLevel, }; - using (var writer = WriterFactory.Open(zipStream, ArchiveType.Zip, writerOptions)) + using (var writer = WriterFactory.OpenWriter(zipStream, ArchiveType.Zip, writerOptions)) { writer.Write( $"{compressionType}_level_{compressionLevel}_{sizeMb}MiB.txt", @@ -146,7 +146,7 @@ public class ZipTypesLevelsWithCrcRatioTests : ArchiveTests // Verify the archive zipStream.Position = 0; - using var archive = ZipArchive.Open(zipStream); + using var archive = ZipArchive.OpenArchive(zipStream); var entry = archive.Entries.Single(e => !e.IsDirectory); using var entryStream = entry.OpenEntryStream(); @@ -201,7 +201,7 @@ public class ZipTypesLevelsWithCrcRatioTests : ArchiveTests // Verify the archive zipStream.Position = 0; - using var archive = ZipArchive.Open(zipStream); + using var archive = ZipArchive.OpenArchive(zipStream); var entry = archive.Entries.Single(e => !e.IsDirectory); using var entryStream = entry.OpenEntryStream(); diff --git a/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs index 7c2d85aa..c7bdf399 100644 --- a/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs @@ -20,7 +20,7 @@ public class ZipReaderAsyncTests : ReaderTests { var path = Path.Combine(TEST_ARCHIVES_PATH, "PrePostHeaders.zip"); using Stream stream = new ForwardOnlyStream(File.OpenRead(path)); - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)); var count = 0; while (await reader.MoveToNextEntryAsync()) { @@ -65,7 +65,7 @@ public class ZipReaderAsyncTests : ReaderTests using Stream stream = new ForwardOnlyStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)); var x = 0; while (await reader.MoveToNextEntryAsync()) { @@ -121,7 +121,7 @@ public class ZipReaderAsyncTests : ReaderTests using ( Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip")) ) - using (IReader baseReader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (IReader baseReader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { IAsyncReader reader = (IAsyncReader)baseReader; while (await reader.MoveToNextEntryAsync()) @@ -145,7 +145,7 @@ public class ZipReaderAsyncTests : ReaderTests using var stream = new TestStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream))) + await using (var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream))) { while (await reader.MoveToNextEntryAsync()) { @@ -169,7 +169,7 @@ public class ZipReaderAsyncTests : ReaderTests File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ) ); - await using var reader = ReaderFactory.OpenAsync(stream); + await using var reader = ReaderFactory.OpenAsyncReader(stream); while (await reader.MoveToNextEntryAsync()) { if (!reader.Entry.IsDirectory) @@ -193,7 +193,7 @@ public class ZipReaderAsyncTests : ReaderTests ) ) using ( - IReader baseReader = ZipReader.Open(stream, new ReaderOptions { Password = "test" }) + IReader baseReader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" }) ) { IAsyncReader reader = (IAsyncReader)baseReader; @@ -220,7 +220,7 @@ public class ZipReaderAsyncTests : ReaderTests File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip")) ) ) - using (IReader baseReader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (IReader baseReader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { IAsyncReader reader = (IAsyncReader)baseReader; while (await reader.MoveToNextEntryAsync()) @@ -247,7 +247,7 @@ public class ZipReaderAsyncTests : ReaderTests File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "zipcrypto.zip")) ) ) - using (IReader baseReader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (IReader baseReader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { IAsyncReader reader = (IAsyncReader)baseReader; while (await reader.MoveToNextEntryAsync()) diff --git a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs index fc87dc57..a5dfc4ca 100644 --- a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs @@ -22,7 +22,7 @@ public class ZipReaderTests : ReaderTests { var path = Path.Combine(TEST_ARCHIVES_PATH, "PrePostHeaders.zip"); using Stream stream = new ForwardOnlyStream(File.OpenRead(path)); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); var count = 0; while (reader.MoveToNextEntry()) { @@ -62,7 +62,7 @@ public class ZipReaderTests : ReaderTests using Stream stream = new ForwardOnlyStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); var x = 0; while (reader.MoveToNextEntry()) { @@ -111,7 +111,7 @@ public class ZipReaderTests : ReaderTests using ( Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip")) ) - using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (var reader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { while (reader.MoveToNextEntry()) { @@ -134,7 +134,7 @@ public class ZipReaderTests : ReaderTests using var stream = new TestStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - using (var reader = ReaderFactory.Open(stream)) + using (var reader = ReaderFactory.OpenReader(stream)) { while (reader.MoveToNextEntry()) { @@ -156,7 +156,7 @@ public class ZipReaderTests : ReaderTests using var stream = new TestStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - var reader = ReaderFactory.Open(stream); + var reader = ReaderFactory.OpenReader(stream); while (reader.MoveToNextEntry()) { if (!reader.Entry.IsDirectory) @@ -179,7 +179,7 @@ public class ZipReaderTests : ReaderTests Path.Combine(TEST_ARCHIVES_PATH, "Zip.lzma.WinzipAES.zip") ) ) - using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (var reader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { while (reader.MoveToNextEntry()) { @@ -204,7 +204,7 @@ public class ZipReaderTests : ReaderTests Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip") ) ) - using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (var reader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { while (reader.MoveToNextEntry()) { @@ -226,7 +226,7 @@ public class ZipReaderTests : ReaderTests { var count = 0; using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "zipcrypto.zip"))) - using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" })) + using (var reader = ZipReader.OpenReader(stream, new ReaderOptions { Password = "test" })) { while (reader.MoveToNextEntry()) { @@ -256,7 +256,7 @@ public class ZipReaderTests : ReaderTests using var memory = new MemoryStream(); Stream stream = new TestStream(memory, read: true, write: true, seek: false); - using (var zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate)) + using (var zipWriter = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate)) { zipWriter.Write(expected[0].Item1, new MemoryStream(expected[0].Item2)); zipWriter.Write(expected[1].Item1, new MemoryStream(expected[1].Item2)); @@ -265,7 +265,7 @@ public class ZipReaderTests : ReaderTests stream = new MemoryStream(memory.ToArray()); File.WriteAllBytes(Path.Combine(SCRATCH_FILES_PATH, "foo.zip"), memory.ToArray()); - using IReader zipReader = ZipReader.Open( + using IReader zipReader = ZipReader.OpenReader( SharpCompressStream.Create(stream, leaveOpen: true, throwOnDispose: true) ); var i = 0; @@ -297,7 +297,7 @@ public class ZipReaderTests : ReaderTests using Stream stream = File.OpenRead( Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.issue86.zip") ); - using var reader = ZipReader.Open(stream); + using var reader = ZipReader.OpenReader(stream); foreach (var key in keys) { reader.MoveToNextEntry(); @@ -319,7 +319,7 @@ public class ZipReaderTests : ReaderTests var keys = new[] { "version", "sizehint", "data/0/metadata", "data/0/records" }; using var fileStream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "test_477.zip")); - using var reader = ZipReader.Open(fileStream); + using var reader = ZipReader.OpenReader(fileStream); foreach (var key in keys) { reader.MoveToNextEntry(); @@ -333,7 +333,7 @@ public class ZipReaderTests : ReaderTests { var count = 0; using var fileStream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Issue_685.zip")); - using var reader = ZipReader.Open(fileStream); + using var reader = ZipReader.OpenReader(fileStream); while (reader.MoveToNextEntry()) { count++; @@ -347,7 +347,7 @@ public class ZipReaderTests : ReaderTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.uncompressed.zip"); using var stream = File.OpenRead(zipPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); while (reader.MoveToNextEntry()) { var target = new MemoryStream(); @@ -360,7 +360,7 @@ public class ZipReaderTests : ReaderTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.uncompressed.zip"); using var stream = File.OpenRead(zipPath); - using var reader = ReaderFactory.Open(stream); + using var reader = ReaderFactory.OpenReader(stream); while (reader.MoveToNextEntry()) { } } @@ -371,10 +371,10 @@ public class ZipReaderTests : ReaderTests { var zipPath = Path.Combine(TEST_ARCHIVES_PATH, "64bitstream.zip.7z"); using var stream = File.OpenRead(zipPath); - var archive = ArchiveFactory.Open(stream); + var archive = ArchiveFactory.OpenArchive(stream); var reader = archive.ExtractAllEntries(); reader.MoveToNextEntry(); - var zipReader = ZipReader.Open(reader.OpenEntryStream()); + var zipReader = ZipReader.OpenReader(reader.OpenEntryStream()); var x = 0; while (zipReader.MoveToNextEntry()) { @@ -387,7 +387,7 @@ public class ZipReaderTests : ReaderTests [Fact] public void Zip_Uncompressed_Encrypted_Read() { - using var reader = ReaderFactory.Open( + using var reader = ReaderFactory.OpenReader( Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.encrypted.zip"), new ReaderOptions { Password = "test" } ); @@ -415,7 +415,7 @@ public class ZipReaderTests : ReaderTests var readerKeys = new List(); using (var stream = File.OpenRead(path)) - using (var reader = ZipReader.Open(stream)) + using (var reader = ZipReader.OpenReader(stream)) { while (reader.MoveToNextEntry()) { @@ -424,7 +424,7 @@ public class ZipReaderTests : ReaderTests } var archiveKeys = new List(); - using (var archive = Archives.Zip.ZipArchive.Open(path)) + using (var archive = Archives.Zip.ZipArchive.OpenArchive(path)) { foreach (var entry in archive.Entries) { diff --git a/tests/SharpCompress.Test/Zip/ZipWriterDirectoryTests.cs b/tests/SharpCompress.Test/Zip/ZipWriterDirectoryTests.cs index a3b2788e..14bc143c 100644 --- a/tests/SharpCompress.Test/Zip/ZipWriterDirectoryTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipWriterDirectoryTests.cs @@ -22,7 +22,7 @@ public class ZipWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = ZipArchive.Open(memoryStream); + using var archive = ZipArchive.OpenArchive(memoryStream); var entries = archive.Entries.ToList(); Assert.Single(entries); @@ -42,7 +42,7 @@ public class ZipWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = ZipArchive.Open(memoryStream); + using var archive = ZipArchive.OpenArchive(memoryStream); var entries = archive.Entries.ToList(); Assert.Single(entries); @@ -62,7 +62,7 @@ public class ZipWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = ZipArchive.Open(memoryStream); + using var archive = ZipArchive.OpenArchive(memoryStream); var entries = archive.Entries.ToList(); Assert.Single(entries); @@ -82,7 +82,7 @@ public class ZipWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = ZipArchive.Open(memoryStream); + using var archive = ZipArchive.OpenArchive(memoryStream); Assert.Empty(archive.Entries); } @@ -101,7 +101,7 @@ public class ZipWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = ZipArchive.Open(memoryStream); + using var archive = ZipArchive.OpenArchive(memoryStream); var entries = archive.Entries.OrderBy(e => e.Key).ToList(); Assert.Equal(3, entries.Count); @@ -132,7 +132,7 @@ public class ZipWriterDirectoryTests : TestBase } memoryStream.Position = 0; - using var archive = ZipArchive.Open(memoryStream); + using var archive = ZipArchive.OpenArchive(memoryStream); var entries = archive.Entries.OrderBy(e => e.Key).ToList(); Assert.Equal(3, entries.Count); diff --git a/tests/SharpCompress.Test/Zip/ZipWriterTests.cs b/tests/SharpCompress.Test/Zip/ZipWriterTests.cs index 82e7caa2..70c2632d 100644 --- a/tests/SharpCompress.Test/Zip/ZipWriterTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipWriterTests.cs @@ -21,7 +21,7 @@ public class ZipWriterTests : WriterTests ArchiveEncoding = new ArchiveEncoding { Default = new UTF8Encoding(false) }, }; - using (var writer = WriterFactory.Open(memoryStream, ArchiveType.Zip, options)) + using (var writer = WriterFactory.OpenWriter(memoryStream, ArchiveType.Zip, options)) { writer.Write("test-folder/zero-byte-file.txt", Stream.Null); } @@ -39,7 +39,7 @@ public class ZipWriterTests : WriterTests ArchiveEncoding = new ArchiveEncoding { Default = new UTF8Encoding(false) }, }; - using (var writer = WriterFactory.Open(memoryStream, ArchiveType.Zip, options)) + using (var writer = WriterFactory.OpenWriter(memoryStream, ArchiveType.Zip, options)) { writer.Write("test-empty-folder/", Stream.Null); }