starred/sharpcompress
1
0
Fork 0
mirror of https://github.com/adamhathcock/sharpcompress.git synced 2026-07-17 22:45:23 +00:00
Code Issues 975 Packages Projects Releases 25 Wiki Activity

merge fixes and fmt

Browse Source
This commit is contained in:
Adam Hathcock
2026-01-15 15:20:52 +00:00
parent c55a383112
commit ec310c87de
18 changed files with 132 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/SharpCompress/Common/AsyncBinaryReader.cs
View File

@@ -51,14 +51,19 @@ namespace SharpCompress.Common
return BinaryPrimitives.ReadUInt64LittleEndian(_buffer);
}
public async ValueTask ReadBytesAsync(byte[] bytes, int offset, int count, CancellationToken ct = default)
public async ValueTask ReadBytesAsync(
byte[] bytes,
int offset,
int count,
CancellationToken ct = default
)
{
await _stream.ReadExactAsync(bytes, offset, count, ct).ConfigureAwait(false);
}
public async ValueTask SkipAsync(int count, CancellationToken ct = default)
{
await _stream.SkipAsync( count, ct).ConfigureAwait(false);
await _stream.SkipAsync(count, ct).ConfigureAwait(false);
}
public void Dispose()

2
src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
View File

@@ -56,7 +56,7 @@ internal class DirectoryEntryHeader : ZipFileEntry
var name = new byte[nameLength];
var extra = new byte[extraLength];
var comment = new byte[commentLength];
await reader.ReadBytesAsync(name,0 ,nameLength);
await reader.ReadBytesAsync(name, 0, nameLength);
await reader.ReadBytesAsync(extra, 0, extraLength);
await reader.ReadBytesAsync(comment, 0, commentLength);

4
src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs
View File

@@ -39,8 +39,8 @@ internal class LocalEntryHeader(IArchiveEncoding archiveEncoding)
var extraLength = await reader.ReadUInt16Async();
var name = new byte[nameLength];
var extra = new byte[extraLength];
await reader.ReadBytesAsync(name,0 ,nameLength);
await reader.ReadBytesAsync(extra, 0, extraLength);
await reader.ReadBytesAsync(name, 0, nameLength);
await reader.ReadBytesAsync(extra, 0, extraLength);
ProcessReadData(name, extra);
}

5
src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs
View File

@@ -39,11 +39,10 @@ internal class Zip64DirectoryEndHeader : ZipHeader
DirectorySize = (long)await reader.ReadUInt64Async();
DirectoryStartOffsetRelativeToDisk = (long)await reader.ReadUInt64Async();
var size = (int)(
SizeOfDirectoryEndRecord
- SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
);
DataSector = new byte[size];
await reader.ReadBytesAsync(DataSector, 0, size);
await reader.ReadBytesAsync(DataSector, 0, size);
}
private const int SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS = 44;

1
src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs
View File

@@ -156,7 +156,6 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
}
}
private static bool IsMatch(Span<byte> haystack, int position, byte[] needle)
{
for (var i = 0; i < needle.Length; i++)

18
src/SharpCompress/Compressors/Deflate/Inflate.cs
View File

@@ -776,11 +776,16 @@ internal sealed class InflateBlocks
// update check information
if (checkfn != null)
{
_codec._adler32 = check = Adler32.Calculate(check, window.Memory.Span.Slice(readAt, nBytes));
_codec._adler32 = check = Adler32.Calculate(
check,
window.Memory.Span.Slice(readAt, nBytes)
);
}
// copy as far as end of window
window.Memory.Span.Slice(readAt, nBytes).CopyTo(_codec.OutputBuffer.AsSpan(_codec.NextOut));
window
.Memory.Span.Slice(readAt, nBytes)
.CopyTo(_codec.OutputBuffer.AsSpan(_codec.NextOut));
_codec.NextOut += nBytes;
readAt += nBytes;
@@ -1469,7 +1474,8 @@ internal sealed class InflateCodes
}
else
{
s.window.Memory.Span.Slice(r, 2).CopyTo(s.window.Memory.Span.Slice(q));
s.window.Memory.Span.Slice(r, 2)
.CopyTo(s.window.Memory.Span.Slice(q));
q += 2;
r += 2;
c -= 2;
@@ -1497,7 +1503,8 @@ internal sealed class InflateCodes
}
else
{
s.window.Memory.Span.Slice(r, e).CopyTo(s.window.Memory.Span.Slice(q));
s.window.Memory.Span.Slice(r, e)
.CopyTo(s.window.Memory.Span.Slice(q));
q += e;
r += e;
e = 0;
@@ -1516,7 +1523,8 @@ internal sealed class InflateCodes
}
else
{
s.window.Memory.Span.Slice(r, c).CopyTo(s.window.Memory.Span.Slice(q));
s.window.Memory.Span.Slice(r, c)
.CopyTo(s.window.Memory.Span.Slice(q));
q += c;
r += c;
c = 0;

1
src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs
View File

@@ -126,7 +126,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
private FileHeader fileHeader;
private void Init()
{
if (this.window is null)

2
src/SharpCompress/IO/BufferedSubStream.cs
View File

@@ -38,7 +38,7 @@ internal class BufferedSubStream : SharpCompressStream, IStreamStack
private int _cacheOffset;
private int _cacheLength;
private readonly byte[] _cache = ArrayPool<byte>.Shared.Rent(32 << 10);
private readonly byte[] _cache = ArrayPool<byte>.Shared.Rent(32 << 10);
private long origin;
private long BytesLeftToRead { get; set; }

27
tests/SharpCompress.Test/Ace/AceReaderAsyncTests.cs
View File

@@ -36,7 +36,10 @@ namespace SharpCompress.Test.Ace
[InlineData("Ace.method1-solid.ace", CompressionType.AceLZ77)]
[InlineData("Ace.method2.ace", CompressionType.AceLZ77)]
[InlineData("Ace.method2-solid.ace", CompressionType.AceLZ77)]
public async ValueTask Ace_Unsupported_ShouldThrow_Async(string fileName, CompressionType compressionType)
public async ValueTask Ace_Unsupported_ShouldThrow_Async(
string fileName,
CompressionType compressionType
)
{
var exception = await Assert.ThrowsAsync<NotSupportedException>(() =>
ReadAsync(fileName, compressionType)
@@ -45,7 +48,10 @@ namespace SharpCompress.Test.Ace
[Theory]
[InlineData("Ace.store.largefile.ace", CompressionType.None)]
public async ValueTask Ace_LargeFileTest_Read_Async(string fileName, CompressionType compressionType)
public async ValueTask Ace_LargeFileTest_Read_Async(
string fileName,
CompressionType compressionType
)
{
await ReadForBufferBoundaryCheckAsync(fileName, compressionType);
}
@@ -62,7 +68,7 @@ namespace SharpCompress.Test.Ace
{
testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
using Stream stream = File.OpenRead(testArchive);
await using var reader = ReaderFactory.OpenAsync(
await using var reader = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(stream),
new ReaderOptions()
);
@@ -80,11 +86,14 @@ namespace SharpCompress.Test.Ace
VerifyFiles();
}
private async Task ReadForBufferBoundaryCheckAsync(string testArchive, CompressionType expectedCompression)
private async Task ReadForBufferBoundaryCheckAsync(
string testArchive,
CompressionType expectedCompression
)
{
testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
using Stream stream = File.OpenRead(testArchive);
await using var reader = ReaderFactory.OpenAsync(
await using var reader = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(stream),
new ReaderOptions() { LookForHeader = false }
);
@@ -104,11 +113,15 @@ namespace SharpCompress.Test.Ace
private async Task DoMultiReaderAsync(string[] archiveNames)
{
var testArchives = archiveNames.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).ToList();
var testArchives = archiveNames
.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s))
.ToList();
var streams = testArchives.Select(File.OpenRead).ToList();
try
{
await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(streams.First()));
await using var reader = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(streams.First())
);
while (await reader.MoveToNextEntryAsync())
{
if (!reader.Entry.IsDirectory)

42
tests/SharpCompress.Test/Arj/ArjReaderAsyncTests.cs
View File

@@ -22,7 +22,8 @@ namespace SharpCompress.Test.Arj
}
[Fact]
public async ValueTask Arj_Uncompressed_Read_Async() => await ReadAsync("Arj.store.arj", CompressionType.None);
public async ValueTask Arj_Uncompressed_Read_Async() =>
await ReadAsync("Arj.store.arj", CompressionType.None);
[Fact]
public async ValueTask Arj_Method1_Read_Async() => await ReadAsync("Arj.method1.arj");
@@ -39,7 +40,9 @@ namespace SharpCompress.Test.Arj
[Fact]
public async ValueTask Arj_Encrypted_Read_Async()
{
var exception = await Assert.ThrowsAsync<CryptographicException>(() => ReadAsync("Arj.encrypted.arj"));
var exception = await Assert.ThrowsAsync<CryptographicException>(() =>
ReadAsync("Arj.encrypted.arj")
);
}
[Fact]
@@ -55,7 +58,7 @@ namespace SharpCompress.Test.Arj
"Arj.store.split.a04",
"Arj.store.split.a05",
],
streams => ReaderFactory.OpenAsync(new AsyncOnlyStream(streams.First()))
streams => ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(streams.First()))
)
);
}
@@ -64,7 +67,10 @@ namespace SharpCompress.Test.Arj
[InlineData("Arj.method1.largefile.arj", CompressionType.ArjLZ77)]
[InlineData("Arj.method2.largefile.arj", CompressionType.ArjLZ77)]
[InlineData("Arj.method3.largefile.arj", CompressionType.ArjLZ77)]
public async ValueTask Arj_LargeFile_ShouldThrow_Async(string fileName, CompressionType compressionType)
public async ValueTask Arj_LargeFile_ShouldThrow_Async(
string fileName,
CompressionType compressionType
)
{
var exception = await Assert.ThrowsAsync<NotSupportedException>(() =>
ReadForBufferBoundaryCheckAsync(fileName, compressionType)
@@ -74,16 +80,22 @@ namespace SharpCompress.Test.Arj
[Theory]
[InlineData("Arj.store.largefile.arj", CompressionType.None)]
[InlineData("Arj.method4.largefile.arj", CompressionType.ArjLZ77)]
public async ValueTask Arj_LargeFileTest_Read_Async(string fileName, CompressionType compressionType)
public async ValueTask Arj_LargeFileTest_Read_Async(
string fileName,
CompressionType compressionType
)
{
await ReadForBufferBoundaryCheckAsync(fileName, compressionType);
}
private async Task ReadAsync(string testArchive, CompressionType? expectedCompression = null)
private async Task ReadAsync(
string testArchive,
CompressionType? expectedCompression = null
)
{
testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
using Stream stream = File.OpenRead(testArchive);
await using var reader = ReaderFactory.OpenAsync(
await using var reader = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(stream),
new ReaderOptions()
);
@@ -104,11 +116,14 @@ namespace SharpCompress.Test.Arj
VerifyFiles();
}
private async Task ReadForBufferBoundaryCheckAsync(string testArchive, CompressionType expectedCompression)
private async Task ReadForBufferBoundaryCheckAsync(
string testArchive,
CompressionType expectedCompression
)
{
testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
using Stream stream = File.OpenRead(testArchive);
await using var reader = ReaderFactory.OpenAsync(
await using var reader = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(stream),
new ReaderOptions() { LookForHeader = false }
);
@@ -126,9 +141,14 @@ namespace SharpCompress.Test.Arj
VerifyFiles();
}
private async Task DoMultiReaderAsync(string[] archiveNames, Func<IEnumerable<Stream>, IAsyncReader> openReader)
private async Task DoMultiReaderAsync(
string[] archiveNames,
Func<IEnumerable<Stream>, IAsyncReader> openReader
)
{
var testArchives = archiveNames.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s)).ToList();
var testArchives = archiveNames
.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s))
.ToList();
var streams = testArchives.Select(File.OpenRead).ToList();
try
{

2
tests/SharpCompress.Test/BZip2/BZip2StreamAsyncTests.cs
View File

@@ -33,7 +33,7 @@ public class BZip2StreamAsyncTests
{
using (
var bzip2Stream = new BZip2Stream(
new AsyncOnlyStream(memoryStream),
new AsyncOnlyStream(memoryStream),
SharpCompress.Compressors.CompressionMode.Compress,
false
)

8
tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs
View File

@@ -70,7 +70,13 @@ public class GZipReaderAsyncTests : ReaderTests
bufferSize: options.BufferSize
);
using var testStream = new TestStream(protectedStream);
await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(testStream), options, default))
await using (
var reader = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(testStream),
options,
default
)
)
{
await UseReaderAsync(reader, expectedCompression);
protectedStream.ThrowOnDispose = false;

4
tests/SharpCompress.Test/Rar/RarArchiveAsyncTests.cs
View File

@@ -654,7 +654,9 @@ public class RarArchiveAsyncTests : ArchiveTests
{
testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
using var stream = File.OpenRead(testArchive);
await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream));
await using var archive = await ArchiveFactory.OpenAsyncArchive(
new AsyncOnlyStream(stream)
);
Assert.True(await archive.IsSolidAsync());
await using (var reader = await archive.ExtractAllEntriesAsync())
{

20
tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs
View File

@@ -17,7 +17,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests
{
var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA.7z");
using var stream = File.OpenRead(testArchive);
await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream));
await using var archive = await ArchiveFactory.OpenAsyncArchive(
new AsyncOnlyStream(stream)
);
await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory))
{
@@ -42,7 +44,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests
{
var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA2.7z");
using var stream = File.OpenRead(testArchive);
await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream));
await using var archive = await ArchiveFactory.OpenAsyncArchive(
new AsyncOnlyStream(stream)
);
await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory))
{
@@ -67,7 +71,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests
{
var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.solid.7z");
using var stream = File.OpenRead(testArchive);
await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream));
await using var archive = await ArchiveFactory.OpenAsyncArchive(
new AsyncOnlyStream(stream)
);
await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory))
{
@@ -92,7 +98,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests
{
var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.BZip2.7z");
using var stream = File.OpenRead(testArchive);
await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream));
await using var archive = await ArchiveFactory.OpenAsyncArchive(
new AsyncOnlyStream(stream)
);
await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory))
{
@@ -117,7 +125,9 @@ public class SevenZipArchiveAsyncTests : ArchiveTests
{
var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.PPMd.7z");
using var stream = File.OpenRead(testArchive);
await using var archive = await ArchiveFactory.OpenAsync(new AsyncOnlyStream(stream));
await using var archive = await ArchiveFactory.OpenAsyncArchive(
new AsyncOnlyStream(stream)
);
await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory))
{

20
tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs
View File

@@ -33,7 +33,13 @@ public class TarArchiveAsyncTests : ArchiveTests
// Step 1: create a tar file containing a file with the test name
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
using (var writer = WriterFactory.OpenAsync(new AsyncOnlyStream(stream), ArchiveType.Tar, CompressionType.None))
using (
var writer = WriterFactory.OpenAsyncWriter(
new AsyncOnlyStream(stream),
ArchiveType.Tar,
CompressionType.None
)
)
using (Stream inputStream = new MemoryStream())
{
var sw = new StreamWriter(inputStream);
@@ -84,7 +90,13 @@ public class TarArchiveAsyncTests : ArchiveTests
// Step 1: create a tar file containing a file with a long name
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
using (var writer = WriterFactory.OpenAsync(new AsyncOnlyStream(stream), ArchiveType.Tar, CompressionType.None))
using (
var writer = WriterFactory.OpenAsyncWriter(
new AsyncOnlyStream(stream),
ArchiveType.Tar,
CompressionType.None
)
)
using (Stream inputStream = new MemoryStream())
{
var sw = new StreamWriter(inputStream);
@@ -187,7 +199,9 @@ public class TarArchiveAsyncTests : ArchiveTests
using (var inputMemory = new MemoryStream(mstm.ToArray()))
{
var tropt = new ReaderOptions { ArchiveEncoding = enc };
await using (var tr = ReaderFactory.OpenAsync(new AsyncOnlyStream(inputMemory), tropt))
await using (
var tr = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(inputMemory), tropt)
)
{
while (await tr.MoveToNextEntryAsync())
{

2
tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs
View File

@@ -73,7 +73,7 @@ public class TarReaderAsyncTests : ReaderTests
public async ValueTask Tar_BZip2_Entry_Stream_Async()
{
using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.bz2")))
await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)))
await using (var reader = ReaderFactory.OpenAsyncReader(new AsyncOnlyStream(stream)))
{
while (await reader.MoveToNextEntryAsync())
{

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

@@ -199,7 +199,10 @@ public class Zip64AsyncTests : WriterTests
ZipEntry? prev = null;
using (var fs = File.OpenRead(filename))
{
var rd = ReaderFactory.OpenAsync(new AsyncOnlyStream(fs), new ReaderOptions { LookForHeader = false });
var rd = ReaderFactory.OpenAsyncReader(
new AsyncOnlyStream(fs),
new ReaderOptions { LookForHeader = false }
);
await using (rd)
{
while (await rd.MoveToNextEntryAsync())

8
tests/SharpCompress.Test/Zip/ZipMemoryArchiveWithCrcAsyncTests.cs
View File

@@ -132,7 +132,13 @@ public class ZipTypesLevelsWithCrcRatioAsyncTests : ArchiveTests
CompressionLevel = compressionLevel,
};
using (var writer = WriterFactory.OpenAsync(new AsyncOnlyStream(zipStream), ArchiveType.Zip, writerOptions))
using (
var writer = WriterFactory.OpenAsyncWriter(
new AsyncOnlyStream(zipStream),
ArchiveType.Zip,
writerOptions
)
)
{
await writer.WriteAsync(
$"{compressionType}_level_{compressionLevel}_{sizeMb}MiB.txt",