starred/sharpcompress
1
0
Fork 0
mirror of https://github.com/adamhathcock/sharpcompress.git synced 2026-09-24 16:05:27 +00:00
Code Issues 975 Packages Projects Releases 25 Wiki Activity

async dispose and fix tests?

Browse Source
This commit is contained in:
Adam Hathcock
2021-01-24 09:18:38 +00:00
parent 3a820c52bd
commit bcdfd992a3
11 changed files with 151 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/SharpCompress/Writers/AbstractWriter.cs
View File

@@ -29,7 +29,14 @@ namespace SharpCompress.Writers
public abstract Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken);
public virtual ValueTask DisposeAsync()
public async ValueTask DisposeAsync()
{
await DisposeAsyncCore();
GC.SuppressFinalize(this);
}
protected virtual ValueTask DisposeAsyncCore()
{
return OutputStream.DisposeAsync();
}

2
src/SharpCompress/Writers/IWriter.cs
View File

@@ -9,6 +9,6 @@ namespace SharpCompress.Writers
public interface IWriter : IAsyncDisposable
{
ArchiveType WriterType { get; }
Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken);
Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken = default);
}
}

4
src/SharpCompress/Writers/Tar/TarWriter.cs
View File

@@ -57,7 +57,7 @@ namespace SharpCompress.Writers.Tar
InitializeStream(destination);
}
public override async Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken)
public override async Task WriteAsync(string filename, Stream source, DateTime? modificationTime, CancellationToken cancellationToken = default)
{
if (!source.CanSeek)
{
@@ -102,7 +102,7 @@ namespace SharpCompress.Writers.Tar
await OutputStream.WriteAsync(zeroBuffer.Memory);
}
public override async ValueTask DisposeAsync()
protected override async ValueTask DisposeAsyncCore()
{
if (finalizeArchiveOnClose)
{

19
tests/SharpCompress.Test/GZip/GZipWriterTests.cs
View File

@@ -1,4 +1,5 @@
using System.IO;
using System.Threading.Tasks;
using SharpCompress.Common;
using SharpCompress.Writers;
using SharpCompress.Writers.GZip;
@@ -15,10 +16,10 @@ namespace SharpCompress.Test.GZip
}
[Fact]
public void GZip_Writer_Generic()
public async Task GZip_Writer_Generic()
{
using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write))
using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.GZip))
await using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.GZip))
{
writer.Write("Tar.tar", Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"));
}
@@ -27,10 +28,10 @@ namespace SharpCompress.Test.GZip
}
[Fact]
public void GZip_Writer()
public async Task GZip_Writer()
{
using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write))
using (var writer = new GZipWriter(stream))
await using (var writer = new GZipWriter(stream))
{
writer.Write("Tar.tar", Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"));
}
@@ -39,22 +40,22 @@ namespace SharpCompress.Test.GZip
}
[Fact]
public void GZip_Writer_Generic_Bad_Compression()
public async Task GZip_Writer_Generic_Bad_Compression()
{
Assert.Throws<InvalidFormatException>(() =>
await Assert.ThrowsAsync<InvalidFormatException>(async () =>
{
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")))
using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.BZip2))
await using (var writer = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.BZip2))
{
}
});
}
[Fact]
public void GZip_Writer_Entry_Path_With_Dir()
public async Task GZip_Writer_Entry_Path_With_Dir()
{
using (Stream stream = File.Open(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"), FileMode.OpenOrCreate, FileAccess.Write))
using (var writer = new GZipWriter(stream))
await using (var writer = new GZipWriter(stream))
{
var path = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar");
writer.Write(path, path); //covers issue #532

198
tests/SharpCompress.Test/Tar/TarArchiveTests.cs
View File

@@ -6,6 +6,8 @@ using SharpCompress.Common;
using SharpCompress.Writers;
using Xunit;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using SharpCompress.Readers;
using SharpCompress.Writers.Tar;
using SharpCompress.Readers.Tar;
@@ -32,7 +34,7 @@ namespace SharpCompress.Test.Tar
}
[Fact]
public void Tar_FileName_Exactly_100_Characters()
public async Task Tar_FileName_Exactly_100_Characters()
{
string archive = "Tar_FileName_Exactly_100_Characters.tar";
@@ -41,16 +43,16 @@ namespace SharpCompress.Test.Tar
string filename = "filename_with_exactly_100_characters_______________________________________________________________X";
// 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 (Stream inputStream = new MemoryStream())
await using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
await using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, CompressionType.None))
await using (Stream inputStream = new MemoryStream())
{
StreamWriter sw = new StreamWriter(inputStream);
sw.Write("dummy filecontent");
sw.Flush();
await sw.WriteAsync("dummy filecontent");
await sw.FlushAsync();
inputStream.Position = 0;
writer.Write(filename, inputStream, null);
await writer.WriteAsync(filename, inputStream, null);
}
// Step 2: check if the written tar file can be read correctly
@@ -62,7 +64,7 @@ namespace SharpCompress.Test.Tar
foreach (var entry in archive2.Entries)
{
Assert.Equal("dummy filecontent", new StreamReader(entry.OpenEntryStream()).ReadLine());
Assert.Equal("dummy filecontent", await new StreamReader(entry.OpenEntryStream()).ReadLineAsync());
}
}
}
@@ -71,19 +73,17 @@ namespace SharpCompress.Test.Tar
public void Tar_NonUstarArchiveWithLongNameDoesNotSkipEntriesAfterTheLongOne()
{
string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "very long filename.tar");
using (var archive = TarArchive.Open(unmodified))
{
Assert.Equal(5, archive.Entries.Count);
Assert.Contains("very long filename/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("very long filename/very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename.jpg", archive.Entries.Select(entry => entry.Key));
Assert.Contains("z_file 1.txt", archive.Entries.Select(entry => entry.Key));
Assert.Contains("z_file 2.txt", archive.Entries.Select(entry => entry.Key));
Assert.Contains("z_file 3.txt", archive.Entries.Select(entry => entry.Key));
}
using var archive = TarArchive.Open(unmodified);
Assert.Equal(5, archive.Entries.Count);
Assert.Contains("very long filename/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("very long filename/very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename.jpg", archive.Entries.Select(entry => entry.Key));
Assert.Contains("z_file 1.txt", archive.Entries.Select(entry => entry.Key));
Assert.Contains("z_file 2.txt", archive.Entries.Select(entry => entry.Key));
Assert.Contains("z_file 3.txt", archive.Entries.Select(entry => entry.Key));
}
[Fact]
public void Tar_VeryLongFilepathReadback()
public async Task Tar_VeryLongFilepathReadback()
{
string archive = "Tar_VeryLongFilepathReadback.tar";
@@ -98,16 +98,16 @@ namespace SharpCompress.Test.Tar
longFilename += ".txt";
// 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 (Stream inputStream = new MemoryStream())
await using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
await using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, CompressionType.None))
await using (Stream inputStream = new MemoryStream())
{
StreamWriter sw = new StreamWriter(inputStream);
sw.Write("dummy filecontent");
sw.Flush();
await sw.WriteAsync("dummy filecontent");
await sw.FlushAsync();
inputStream.Position = 0;
writer.Write(longFilename, inputStream, null);
await writer.WriteAsync(longFilename, inputStream, null);
}
// Step 2: check if the written tar file can be read correctly
@@ -119,29 +119,27 @@ namespace SharpCompress.Test.Tar
foreach (var entry in archive2.Entries)
{
Assert.Equal("dummy filecontent", new StreamReader(entry.OpenEntryStream()).ReadLine());
Assert.Equal("dummy filecontent", await new StreamReader(entry.OpenEntryStream()).ReadLineAsync());
}
}
}
[Fact]
public void Tar_UstarArchivePathReadLongName()
public async Task Tar_UstarArchivePathReadLongName()
{
string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "ustar with long names.tar");
using (var archive = TarArchive.Open(unmodified))
{
Assert.Equal(6, archive.Entries.Count);
Assert.Contains("Directory/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
}
using var archive = TarArchive.Open(unmodified);
Assert.Equal(6, archive.Entries.Count);
Assert.Contains("Directory/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
}
[Fact]
public void Tar_Create_New()
public async Task Tar_Create_New()
{
string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.tar");
string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar");
@@ -161,7 +159,7 @@ namespace SharpCompress.Test.Tar
CompareArchivesByPath(unmodified, scratchPath);
}
[Fact]
public void Tar_Random_Write_Add()
public async Task Tar_Random_Write_Add()
{
string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg");
string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.mod.tar");
@@ -177,7 +175,7 @@ namespace SharpCompress.Test.Tar
}
[Fact]
public void Tar_Random_Write_Remove()
public async Task Tar_Random_Write_Remove()
{
string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.mod.tar");
string modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar");
@@ -193,100 +191,90 @@ namespace SharpCompress.Test.Tar
}
[Fact]
public void Tar_Containing_Rar_Archive()
public async Task Tar_Containing_Rar_Archive()
{
string archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.ContainsRar.tar");
using (Stream stream = File.OpenRead(archiveFullPath))
using (IArchive archive = ArchiveFactory.Open(stream))
{
Assert.True(archive.Type == ArchiveType.Tar);
}
using Stream stream = File.OpenRead(archiveFullPath);
using IArchive archive = ArchiveFactory.Open(stream);
Assert.True(archive.Type == ArchiveType.Tar);
}
[Fact]
public void Tar_Empty_Archive()
public async Task Tar_Empty_Archive()
{
string archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.Empty.tar");
using (Stream stream = File.OpenRead(archiveFullPath))
using (IArchive archive = ArchiveFactory.Open(stream))
{
Assert.True(archive.Type == ArchiveType.Tar);
}
using Stream stream = File.OpenRead(archiveFullPath);
using IArchive archive = ArchiveFactory.Open(stream);
Assert.True(archive.Type == ArchiveType.Tar);
}
[Theory]
[InlineData(10)]
[InlineData(128)]
public void Tar_Japanese_Name(int length)
public async Task Tar_Japanese_Name(int length)
{
using (var mstm = new MemoryStream())
using var mstm = new MemoryStream();
var enc = new ArchiveEncoding()
{
Default = Encoding.UTF8
};
var twopt = new TarWriterOptions(CompressionType.None, true);
twopt.ArchiveEncoding = enc;
var fname = new string((char)0x3042, length);
await using (var tw = new TarWriter(mstm, twopt))
using (var input = new MemoryStream(new byte[32]))
{
var enc = new ArchiveEncoding()
await tw.WriteAsync(fname, input, null);
}
using (var inputMemory = new MemoryStream(mstm.ToArray()))
{
var tropt = new ReaderOptions()
{
ArchiveEncoding = enc
};
using (var tr = TarReader.Open(inputMemory, tropt))
{
Default = Encoding.UTF8
};
var twopt = new TarWriterOptions(CompressionType.None, true);
twopt.ArchiveEncoding = enc;
var fname = new string((char)0x3042, length);
using (var tw = new TarWriter(mstm, twopt))
using (var input = new MemoryStream(new byte[32]))
{
tw.Write(fname, input, null);
}
using (var inputMemory = new MemoryStream(mstm.ToArray()))
{
var tropt = new ReaderOptions()
while (tr.MoveToNextEntry())
{
ArchiveEncoding = enc
};
using (var tr = TarReader.Open(inputMemory, tropt))
{
while (tr.MoveToNextEntry())
{
Assert.Equal(fname, tr.Entry.Key);
}
Assert.Equal(fname, tr.Entry.Key);
}
}
}
}
[Fact]
public void Tar_Read_One_At_A_Time()
public async Task Tar_Read_One_At_A_Time()
{
var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8, };
var tarWriterOptions = new TarWriterOptions(CompressionType.None, true) { ArchiveEncoding = archiveEncoding, };
var testBytes = Encoding.UTF8.GetBytes("This is a test.");
using (var memoryStream = new MemoryStream())
using var memoryStream = new MemoryStream();
await using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions))
using (var testFileStream = new MemoryStream(testBytes))
{
using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions))
using (var testFileStream = new MemoryStream(testBytes))
{
tarWriter.Write("test1.txt", testFileStream);
testFileStream.Position = 0;
tarWriter.Write("test2.txt", testFileStream);
}
memoryStream.Position = 0;
var numberOfEntries = 0;
using (var archiveFactory = TarArchive.Open(memoryStream))
{
foreach (var entry in archiveFactory.Entries)
{
++numberOfEntries;
using (var tarEntryStream = entry.OpenEntryStream())
using (var testFileStream = new MemoryStream())
{
tarEntryStream.CopyTo(testFileStream);
Assert.Equal(testBytes.Length, testFileStream.Length);
}
}
}
Assert.Equal(2, numberOfEntries);
tarWriter.Write("test1.txt", testFileStream);
testFileStream.Position = 0;
tarWriter.Write("test2.txt", testFileStream);
}
memoryStream.Position = 0;
var numberOfEntries = 0;
using (var archiveFactory = TarArchive.Open(memoryStream))
{
foreach (var entry in archiveFactory.Entries)
{
++numberOfEntries;
using var tarEntryStream = entry.OpenEntryStream();
using var testFileStream = new MemoryStream();
await tarEntryStream.CopyToAsync(testFileStream);
Assert.Equal(testBytes.Length, testFileStream.Length);
}
}
Assert.Equal(2, numberOfEntries);
}
}
}

23
tests/SharpCompress.Test/Tar/TarWriterTests.cs
View File

@@ -1,5 +1,6 @@
using System.IO;
using System.Text;
using System.Threading.Tasks;
using SharpCompress.Common;
using SharpCompress.Writers.Tar;
using Xunit;
@@ -15,40 +16,40 @@ namespace SharpCompress.Test.Tar
}
[Fact]
public void Tar_Writer()
public async Task Tar_Writer()
{
Write(CompressionType.None, "Tar.noEmptyDirs.tar", "Tar.noEmptyDirs.tar", Encoding.GetEncoding(866));
await WriteAsync(CompressionType.None, "Tar.noEmptyDirs.tar", "Tar.noEmptyDirs.tar", Encoding.GetEncoding(866));
}
[Fact]
public void Tar_BZip2_Writer()
public async Task Tar_BZip2_Writer()
{
Write(CompressionType.BZip2, "Tar.noEmptyDirs.tar.bz2", "Tar.noEmptyDirs.tar.bz2", Encoding.GetEncoding(866));
await WriteAsync(CompressionType.BZip2, "Tar.noEmptyDirs.tar.bz2", "Tar.noEmptyDirs.tar.bz2", Encoding.GetEncoding(866));
}
[Fact]
public void Tar_LZip_Writer()
public async Task Tar_LZip_Writer()
{
Write(CompressionType.LZip, "Tar.noEmptyDirs.tar.lz", "Tar.noEmptyDirs.tar.lz", Encoding.GetEncoding(866));
await WriteAsync(CompressionType.LZip, "Tar.noEmptyDirs.tar.lz", "Tar.noEmptyDirs.tar.lz", Encoding.GetEncoding(866));
}
[Fact]
public void Tar_Rar_Write()
public async Task Tar_Rar_Write()
{
Assert.Throws<InvalidFormatException>(() => Write(CompressionType.Rar, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip"));
await Assert.ThrowsAsync<InvalidFormatException>(async () => await WriteAsync(CompressionType.Rar, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip"));
}
[Theory]
[InlineData(true)]
[InlineData(false)]
public void Tar_Finalize_Archive(bool finalizeArchive)
public async Task Tar_Finalize_Archive(bool finalizeArchive)
{
using (MemoryStream stream = new MemoryStream())
using (Stream content = File.OpenRead(Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg")))
{
using (TarWriter writer = new TarWriter(stream, new TarWriterOptions(CompressionType.None, finalizeArchive)))
await using (TarWriter writer = new TarWriter(stream, new TarWriterOptions(CompressionType.None, finalizeArchive)))
{
writer.Write("doesn't matter", content, null);
await writer.WriteAsync("doesn't matter", content, null);
}
var paddedContentWithHeader = content.Length / 512 * 512 + 512 + 512;

5
tests/SharpCompress.Test/WriterTests.cs
View File

@@ -1,5 +1,6 @@
using System.IO;
using System.Text;
using System.Threading.Tasks;
using SharpCompress.Common;
using SharpCompress.IO;
using SharpCompress.Readers;
@@ -16,7 +17,7 @@ namespace SharpCompress.Test
this.type = type;
}
protected void Write(CompressionType compressionType, string archive, string archiveToVerifyAgainst, Encoding encoding = null)
protected async Task WriteAsync(CompressionType compressionType, string archive, string archiveToVerifyAgainst, Encoding encoding = null)
{
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
{
@@ -27,7 +28,7 @@ namespace SharpCompress.Test
writerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default;
using (var writer = WriterFactory.Open(stream, type, writerOptions))
await using (var writer = WriterFactory.Open(stream, type, writerOptions))
{
writer.WriteAll(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories);
}

5
tests/SharpCompress.Test/Zip/Zip64Tests.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using SharpCompress.Archives;
using SharpCompress.Common;
using SharpCompress.Readers;
@@ -136,7 +137,7 @@ namespace SharpCompress.Test.Zip
}
}
public void CreateZipArchive(string filename, long files, long filesize, long chunksize, bool set_zip64, bool forward_only)
public async Task CreateZipArchive(string filename, long files, long filesize, long chunksize, bool set_zip64, bool forward_only)
{
var data = new byte[chunksize];
@@ -148,7 +149,7 @@ namespace SharpCompress.Test.Zip
using (var zip = File.OpenWrite(filename))
using (var st = forward_only ? (Stream)new ForwardOnlyStream(zip) : zip)
using (var zipWriter = (ZipWriter)WriterFactory.Open(st, ArchiveType.Zip, opts))
await using (var zipWriter = (ZipWriter)WriterFactory.Open(st, ArchiveType.Zip, opts))
{
for (var i = 0; i < files; i++)

5
tests/SharpCompress.Test/Zip/ZipArchiveTests.cs
View File

@@ -2,6 +2,7 @@
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SharpCompress.Archives;
using SharpCompress.Archives.Zip;
using SharpCompress.Common;
@@ -490,11 +491,11 @@ namespace SharpCompress.Test.Zip
}
[Fact]
public void TestSharpCompressWithEmptyStream()
public async Task TestSharpCompressWithEmptyStream()
{
MemoryStream stream = new NonSeekableMemoryStream();
using (IWriter zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
await using (IWriter zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
{
zipWriter.Write("foo.txt", new MemoryStream(new byte[0]));
zipWriter.Write("foo2.txt", new MemoryStream(new byte[10]));

5
tests/SharpCompress.Test/Zip/ZipReaderTests.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.IO;
using System.Threading.Tasks;
using SharpCompress.Common;
using SharpCompress.IO;
using SharpCompress.Readers;
@@ -270,7 +271,7 @@ namespace SharpCompress.Test.Zip
}
[Fact]
public void TestSharpCompressWithEmptyStream()
public async Task TestSharpCompressWithEmptyStream()
{
var expected = new Tuple<string, byte[]>[]
{
@@ -282,7 +283,7 @@ namespace SharpCompress.Test.Zip
{
Stream stream = new TestStream(memory, read: true, write: true, seek: false);
using (IWriter zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
await using (IWriter zipWriter = WriterFactory.Open(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));

26
tests/SharpCompress.Test/Zip/ZipWriterTests.cs
View File

@@ -1,5 +1,5 @@
using System.Text;
using System.Threading.Tasks;
using SharpCompress.Common;
using Xunit;
@@ -14,40 +14,40 @@ namespace SharpCompress.Test.Zip
[Fact]
public void Zip_Deflate_Write()
public async Task Zip_Deflate_Write()
{
Write(CompressionType.Deflate, "Zip.deflate.noEmptyDirs.zip", "Zip.deflate.noEmptyDirs.zip", Encoding.UTF8);
await WriteAsync(CompressionType.Deflate, "Zip.deflate.noEmptyDirs.zip", "Zip.deflate.noEmptyDirs.zip", Encoding.UTF8);
}
[Fact]
public void Zip_BZip2_Write()
public async Task Zip_BZip2_Write()
{
Write(CompressionType.BZip2, "Zip.bzip2.noEmptyDirs.zip", "Zip.bzip2.noEmptyDirs.zip", Encoding.UTF8);
await WriteAsync(CompressionType.BZip2, "Zip.bzip2.noEmptyDirs.zip", "Zip.bzip2.noEmptyDirs.zip", Encoding.UTF8);
}
[Fact]
public void Zip_None_Write()
public async Task Zip_None_Write()
{
Write(CompressionType.None, "Zip.none.noEmptyDirs.zip", "Zip.none.noEmptyDirs.zip", Encoding.UTF8);
await WriteAsync(CompressionType.None, "Zip.none.noEmptyDirs.zip", "Zip.none.noEmptyDirs.zip", Encoding.UTF8);
}
[Fact]
public void Zip_LZMA_Write()
public async Task Zip_LZMA_Write()
{
Write(CompressionType.LZMA, "Zip.lzma.noEmptyDirs.zip", "Zip.lzma.noEmptyDirs.zip", Encoding.UTF8);
await WriteAsync(CompressionType.LZMA, "Zip.lzma.noEmptyDirs.zip", "Zip.lzma.noEmptyDirs.zip", Encoding.UTF8);
}
[Fact]
public void Zip_PPMd_Write()
public async Task Zip_PPMd_Write()
{
Write(CompressionType.PPMd, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip", Encoding.UTF8);
await WriteAsync(CompressionType.PPMd, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip", Encoding.UTF8);
}
[Fact]
public void Zip_Rar_Write()
public async Task Zip_Rar_Write()
{
Assert.Throws<InvalidFormatException>(() => Write(CompressionType.Rar, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip"));
await Assert.ThrowsAsync<InvalidFormatException>(async () => await WriteAsync(CompressionType.Rar, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip"));
}
}
}